base of folders in collections

src/js/modules/common_project_management/project_data_store.js

@@ -37,6 +37,9 @@ var createProjectStore = function(){
             evaluators:["uuid","type"],
             links:["uuid","type","from","to"],
             relationsInstances:["uuid","type","from","to"],
+            structures:["uuid","name","type"],
+            hierarchies:["uuid","type","from","to"],
+            references:["uuid","type","from","to"],
 
         },{persistence:projectId, crdt:true, syncTo:false})
         // },{persistence:projectId, crdt:true, syncTo:"http://127.0.0.1:3000/crdtGeneral"})

src/js/modules/common_project_management/structures_management.js

@@ -0,0 +1,185 @@
+import createRepoManagement from "./repo_management.js";
+import projectManagement from "./project_management.js";
+import createRelationsManagement from "./relations_management.js";
+import projectStores from "./project_data_store.js";
+import nanoid from "../../vendor/nanoid.js";
+import createEntityManagement from "./entity_management.js";
+
+var structureAggregate = function(aggregate, projectStore){
+
+    var propNameUuidMapping = {}
+    var propUuidNameMapping = {}
+
+    //parameters "Properties"
+    var ownProperties = {}
+    var sourceEntity = projectStore.get("entities").where("uuid").equals(aggregate.attributes.type)
+    for (const key in sourceEntity) {
+        if (Object.hasOwnProperty.call(sourceEntity, key) && key.search("prop_")>=0) {
+            const element = sourceEntity[key];
+            //TODO check if ref is still used
+            // ownProperties.push({uuid:key, value:aggregate.attributes[key]})
+            var property = projectStore.get("properties").where("uuid").equals(key.substring(5))
+            if (property) {
+                var propertyName = property.name
+                propNameUuidMapping[propertyName]=key
+                propUuidNameMapping[key]=propertyName
+                ownProperties[propertyName] = aggregate.attributes[key]
+                ownProperties[propertyName] = {property:property, value:aggregate.attributes[key]} 
+            }
+
+        }
+    }      
+    aggregate.properties = ownProperties
+
+    //parameters "Relations"
+    var ownRelations = []
+    var currentRelations = projectStore.get("hierarchies").toArray()
+    for (let i = 0; i < currentRelations.length; i++) {
+        const element = currentRelations[i];
+        if (element.from == aggregate.uuid) {
+            ownRelations.push(element);
+        }
+    }
+    aggregate.relations = ownRelations
+    // aggregate.color = sourceEntity.color
+    // aggregate.sourceEntity = sourceEntity
+
+    //methods
+    aggregate.getRelations = function () {
+        var ownRelations = []
+        var currentRelations = projectStore.get("hierarchies").toArray()
+        for (let i = 0; i < currentRelations.length; i++) {
+            const element = currentRelations[i];
+            if (element.from == aggregate.uuid) {
+                ownRelations.push(element);
+            }
+            if (element.to == aggregate.uuid) {
+                ownRelations.push(element);
+            }
+        }
+        return ownRelations
+    }
+
+
+
+    //methods
+    aggregate.setPropertyByName = function (propName, value) {
+        var propRef = propNameUuidMapping[propName]
+        if (propRef) {
+            // var newObject = {uuid:aggregate.uuid,[ "prop_"+propRef ]:value}
+            var newObject = {uuid:aggregate.uuid,[ propRef ]:value} //TODO check why 'prop' is not needed
+            projectStore.add("structures",newObject)
+        }else{
+            console.warn("No property named "+ propRef);
+        }
+    }
+    aggregate.setPropertyByUuid = function (propRef, value) {
+
+        var newObject = {uuid:aggregate.uuid,[ "prop_"+propRef ]:value}
+        projectStore.add("structures",newObject)
+    }
+
+    //methods
+    aggregate.addRelation = function (type, targetId) {
+        var currentRelationTarget = projectStore.get("structures").where("uuid").equals(targetId)
+        projectStore.add("hierarchies",{name:`from ${aggregate.name} to ${currentRelationTarget.name}`, from:aggregate.uuid, to:currentRelationTarget.uuid, type:type})
+    }
+    aggregate.addRelationFromSource = function (type, sourceId) {
+        var currentRelationSource = projectStore.get("structures").where("uuid").equals(sourceId)
+        projectStore.add("hierarchies",{name:`from ${currentRelationSource.name} to ${aggregate.name} `, to:aggregate.uuid, from:currentRelationSource.uuid, type:type})
+    }
+    aggregate.removeRelation = function (type, targetId) {
+        var currentRelationTarget = projectStore.get("hierarchies").where("type").equals(type)
+        var relationToRemove = undefined;
+        for (let i = 0; i < currentRelationTarget.length; i++) {
+            const element = currentRelationTarget[i];
+            if (element.to == targetId) { relationToRemove = element  }
+        }
+        if (relationToRemove) {
+            projectStore.remove("hierarchies",relationToRemove.uuid)
+        }
+
+    }
+    aggregate.removeRelationFromSource = function (type, sourceId) {
+        var currentRelationTarget = projectStore.get("hierarchies").where("type").equals(type)
+        var relationToRemove = undefined;
+        for (let i = 0; i < currentRelationTarget.length; i++) {
+            const element = currentRelationTarget[i];
+            if (element.from == sourceId) { relationToRemove = element  }
+        }
+        if (relationToRemove) {
+            projectStore.remove("hierarchies",relationToRemove.uuid)
+        }
+
+    }
+
+    return aggregate
+}
+
+var customRepoMethods = function (projectStore,createAggregate) {
+    var repo = {}
+
+    repo.getByType = function(targetId){
+        var exportedByType = []
+        var entities = projectStore.get("structures").where("type").equals(targetId)
+        for (let i = 0; i < entities.length; i++) {
+            const element = entities[i];
+            exportedByType.push(createAggregate(element))
+        }
+        return exportedByType
+    }
+
+    repo.createFrom =function (sourceId, data) {
+        var currentUuid = nanoid()
+        data.uuid = currentUuid
+        projectStore.add("structures",data)
+        // projectStore.add("hierarchies",{name:`from ${sourceId} to ${data.name}`, from:sourceId, to:currentUuid, type:type || undefined})
+        projectStore.add("hierarchies",{name:`from ${sourceId} to ${data.name}`, from:sourceId, to:currentUuid,})
+    }
+
+    repo.getChildrenOfId = function (sourceId) {
+        var toReturn = []
+        var sourceToChildMapping ={}
+        var childToSourceMapping ={}
+        var currentHierarchies = projectStore.get("hierarchies").toArray()
+        var currentStructures = projectStore.get("structures").toArray()
+        for (let i = 0; i < currentHierarchies.length; i++) {
+            const element = currentHierarchies[i];
+            sourceToChildMapping[element.from] = element.to  
+            childToSourceMapping[element.to] = element.from  
+        }
+        for (let i = 0; i < currentStructures.length; i++) {
+            const structure = currentStructures[i];
+            if (childToSourceMapping[structure.uuid] == sourceId) {
+                toReturn.push(structure)
+            }
+
+        }
+        // console.log(sourceToChildMapping);
+        // console.log(childToSourceMapping);
+        // console.log(currentStructures);
+        // console.log(currentHierarchies);
+        // console.log(toReturn);
+        // console.log(sourceId);
+        // alert("eeefg")
+        return toReturn
+    }
+
+    repo.link = function (sourceId, targetId) {
+        var currentRelationTarget = projectStore.get("structures").where("uuid").equals(targetId)
+        var currentRelationSource = projectStore.get("structures").where("uuid").equals(sourceId)
+        if (currentRelationTarget && currentRelationSource) {
+            projectStore.add("hierarchies",{name:`from ${currentRelationSource.name} to ${currentRelationSource.name}`, from:currentRelationSource.uuid, to:currentRelationTarget.uuid, type:type})
+        }else{
+            console.warn("Missing source or target")
+        }
+    }
+
+    return repo
+}
+
+var createStructuresManagement = function () {
+    return createRepoManagement(projectManagement.getCurrent().id, 'structures', structureAggregate, customRepoMethods)
+}
+
+export default createStructuresManagement

src/js/modules/common_ui_components/folder_view/folder_view.js

@@ -86,12 +86,22 @@ var setUpTable = function(self){
 //     self.tablepr.replaceData(self.list) //load data array
 // }
 
+var setUpActionMenu = function(self){
+    self.query(".add").addEventListener("click", function (event) {
+        self.addItem(event)
+    })
+}
+
 var folder_view_component =createAdler({
     tag:'folder-view',
     props:{
         onClick:function (e,cell) {
             alert("no action")
             // state_manager.setSearchParams("test","tas", "silent")
+        },
+        addItem:function (e) {
+            alert("no action")
+            // state_manager.setSearchParams("test","tas", "silent")
         }
         // test:15,
         // dataList:[],
@@ -119,7 +129,7 @@ var folder_view_component =createAdler({
     ],
     onRender:(self) =>{
         setUpTable(self)
-
+        setUpActionMenu(self)
     },
     html: p => /*html*/`
     <link rel="stylesheet" href="css/vendor/tabulator_semanticui.min.css">
@@ -129,6 +139,7 @@ var folder_view_component =createAdler({
 
 
     <div class="folder_view">
+        <div class="add">add</div>
         <input type="text" placeholder="Search.." class="stellae_inj_css_side_search">
         <div class="tableComponent"></div>
     </div>

src/js/modules/tools_collections/tools_collections.js

@@ -4,6 +4,9 @@ import folder_view_component from "../common_ui_components/folder_view/folder_vi
 import state from "../common_state/state_manager.js";
 import createInstancesManagement from "../common_project_management/instances_management.js";
 import project_views from "../project_views/project_views.js";
+import createStructuresManagement from "../common_project_management/structures_management.js";
+
+
 
 var showCollections = function (self) {
     var entitiesRepo = createEntityManagement()
@@ -34,6 +37,7 @@ var loadSideMenu = function (self) {
         return{name:i.name, uuid:i.uuid}
     })
     folderComponent.onClick = sideMenuClickAction(self)
+    folderComponent.addItem = addClickAction(self)
     folderComponent.list = [
         {name:currentEntity.name, _children:instancesList},
         // {name:"Chapitre 2 ", _children:[
@@ -42,7 +46,16 @@ var loadSideMenu = function (self) {
         // ]},
     ];
 
+    var structuresRep = createStructuresManagement()
+    // var structuresList = structuresRep.getAll()
+    var structuresList = structuresRep.getChildrenOfId(self.instanceId)
+    for (let i = 0; i < structuresList.length; i++) {
+        const element = structuresList[i];
+        folderComponent.list.push({name:element.name})
+    }
+
     self.query(".collection_side_view").append(folderComponent)
+    // subscribeToChanges(event, data, instance, softUpdate)
 }
 
 var sideMenuClickAction = function (self) {
@@ -68,6 +81,21 @@ var sideMenuClickAction = function (self) {
     }
 }
 
+var addClickAction = function (self) {
+    // console.log(e);
+    // console.log(cell.getData());
+    return function (event) {
+        var name = prompt("Folder Name")
+        if (name) {
+            var repo = createStructuresManagement()
+            var created = repo.createFrom(self.instanceId, {name:name, type:"folder"})
+            console.log(created);
+        }
+
+    }
+
+}
+
 
 var toolsCollections =createAdler({
     tag:'collections-view',