fixes in attribute persistence + WIP on display of promoted attrs

src/routes/api/attributes.js

@@ -5,10 +5,53 @@ const attributeService = require('../../services/attributes');
 const repository = require('../../services/repository');
 const Attribute = require('../../entities/attribute');
 
-async function getNoteAttributes(req) {
+async function getEffectiveNoteAttributes(req) {
     const noteId = req.params.noteId;
 
-    return await repository.getEntities("SELECT * FROM attributes WHERE isDeleted = 0 AND noteId = ? ORDER BY position, dateCreated", [noteId]);
+    const attributes = await repository.getEntities(`
+        WITH RECURSIVE tree(noteId, level) AS (
+        SELECT ?, 0
+            UNION
+            SELECT branches.parentNoteId, tree.level + 1 FROM branches
+            JOIN tree ON branches.noteId = tree.noteId
+            JOIN notes ON notes.noteId = branches.parentNoteId
+            WHERE notes.isDeleted = 0 AND branches.isDeleted = 0
+        )
+        SELECT attributes.* FROM attributes JOIN tree ON attributes.noteId = tree.noteId 
+        WHERE attributes.isDeleted = 0 AND (attributes.isInheritable = 1 OR attributes.noteId = ?)
+        ORDER BY level, noteId, position`, [noteId, noteId]);
+        // attributes are ordered so that "closest" attributes are first
+        // we order by noteId so that attributes from same note stay together. Actual noteId ordering doesn't matter.
+
+    const filteredAttributes = attributes.filter((attr, index) => {
+        if (attr.isDefinition()) {
+            const firstDefinitionIndex = attributes.findIndex(el => el.type === attr.type && el.name === attr.name);
+
+            // keep only if this element is the first definition for this type & name
+            return firstDefinitionIndex === index;
+        }
+        else {
+            const definitionAttr = attributes.find(el => el.type === attr.type + '-definition' && el.name === attr.name);
+
+            if (!definitionAttr) {
+                return true;
+            }
+
+            const definition = definitionAttr.value;
+
+            if (definition.multiplicityType === 'multivalue') {
+                return true;
+            }
+            else {
+                const firstAttrIndex = attributes.findIndex(el => el.type === attr.type && el.name === attr.name);
+
+                // in case of single-valued attribute we'll keep it only if it's first (closest)
+                return firstAttrIndex === index;
+            }
+        }
+    });
+
+    return filteredAttributes;
 }
 
 async function updateNoteAttributes(req) {
@@ -38,6 +81,8 @@ async function updateNoteAttributes(req) {
         attributeEntity.isInheritable = attribute.isInheritable;
         attributeEntity.isDeleted = attribute.isDeleted;
 
+        console.log("ATTR: ", attributeEntity);
+
         await attributeEntity.save();
     }
 
@@ -58,8 +103,8 @@ async function getValuesForAttribute(req) {
 }
 
 module.exports = {
-    getNoteAttributes,
     updateNoteAttributes,
     getAttributeNames,
-    getValuesForAttribute
+    getValuesForAttribute,
+    getEffectiveNoteAttributes
 };