libreqda 1.2.0__py3-none-any.whl

taguette/static/js/collection/hierarchy-select.js

@@ -0,0 +1,71 @@
+const collection_hierarchy_select = $('#collection-hierarchy-select');
+const document_collection_hierarchy_select = $('#document-collection-hierarchy-select');
+const hs_menu_inner_collection = $('.hs-menu-inner');
+const hs_menu_inner_document = $('.hs-menu-inner');
+
+const COLLECTION_DEFAULT_LEVEL = 1;
+
+// Creates a default 'None' option for collections
+function addDefaultValueCollection(parentContainer) {
+    const li = $("<li>");
+    const a = $("<a>").addClass("dropdown-item")
+        .attr("data-value", '')
+        .attr("data-default-selected", '')
+        .attr("data-level", COLLECTION_DEFAULT_LEVEL)
+        .text(gettext('None'));
+    li.append(a);
+
+    parentContainer.append(li);
+}
+
+// Recursively generates items from collection hierarchy data
+function generateCollectionHierarchyItem(data, parentContainer, level) {
+    $.each(data, function (index, item) {
+        if (!item) return;
+        
+        const li = $("<li>");
+        const a = $("<a>").addClass("dropdown-item")
+            .attr("data-value", item.id)
+            .attr("data-level", level)
+            .attr("href", "#")
+            .text(item.name);
+
+        li.append(a);
+        parentContainer.append(li);
+
+        if (item.children && item.children.length > 0) {
+            generateCollectionHierarchyItem(item.children, parentContainer, level + COLLECTION_DEFAULT_LEVEL);
+        }
+    });
+}
+
+// Init collection hierarchy select dropdown for create collection
+function initCollectionHierarchySelect() {
+    initHierarchySelectCollection(hs_menu_inner_collection, collection_hierarchy_select, true);
+}
+
+// Sets up a hierarchy select dropdown for collections
+function initHierarchySelectCollection(menu, select, withDefault = true) {
+    menu.html('');
+
+    if(withDefault) {
+        addDefaultValueCollection(menu);
+    }
+
+    generateCollectionHierarchyItem(collections, menu, COLLECTION_DEFAULT_LEVEL);
+
+    select.hierarchySelect({
+        width: 'auto'
+    });
+}
+
+
+function initDocumentCollectionHierarchySelect(initialValueSet = false) {
+    initHierarchySelectCollection(hs_menu_inner_document, document_collection_hierarchy_select, true, initialValueSet);
+}
+
+// Init document change collection hierarchy select dropdown
+function initDocumentChangeCollectionHierarchySelect(initialValueSet = false) {
+    const document_change_collection_hierarchy_select = $('#document-change-collection-hierarchy-select');
+    initHierarchySelectCollection(hs_menu_inner_document, document_change_collection_hierarchy_select, true, initialValueSet);
+} 

taguette/static/js/collection/manager.js

@@ -0,0 +1,217 @@
+// Collection management: add, update, remove
+
+function addCollection(collectionData) {
+    // Check if collection already exists to prevent duplicates
+    const existingCollection = findCollection(parseInt(collectionData.id));
+    if (existingCollection) {
+        // Update existing collection instead of creating duplicate
+        existingCollection.name = collectionData.name;
+        existingCollection.description = collectionData.description;
+        existingCollection.document_ids = collectionData.document_ids;
+        initDocumentsTreeview();
+        return;
+    }
+    
+    const newCollection = {
+        id: collectionData.id,
+        name: collectionData.name,
+        description: collectionData.description,
+        parent: collectionData.parent_id,
+        document_ids: collectionData.document_ids,
+        children: []
+    };
+    
+    if (!collections) {
+        collections = [];
+    }
+    
+    // Check if collection has parent
+    if (collectionData.parent_id) {
+        const parentCollection = findCollection(parseInt(collectionData.parent_id));
+        if (parentCollection) {
+            if (!parentCollection.children) {
+                parentCollection.children = [];
+            }
+            parentCollection.children.push(newCollection);
+        } else {
+            // Parent not found, add to root level
+            collections.push(newCollection);
+        }
+    } else {
+        // Root level collection
+        collections.push(newCollection);
+    }
+    
+    // Update document collections
+    if (collectionData.document_ids && collectionData.document_ids.length > 0) {
+        for (let docId of collectionData.document_ids) {
+            const document = documents[docId.toString()];
+            if (document) {
+                // Remove document from all existing collections first
+                if (document.collections && document.collections.length > 0) {
+                    for (let existingCollectionId of document.collections) {
+                        const existingCollection = findCollection(existingCollectionId);
+                        if (existingCollection && existingCollection.document_ids) {
+                            const docIndex = existingCollection.document_ids.indexOf(parseInt(docId));
+                            if (docIndex !== -1) {
+                                existingCollection.document_ids.splice(docIndex, 1);
+                            }
+                        }
+                    }
+                }
+                
+                // Add document to new collection
+                if (!document.collections) {
+                    document.collections = [];
+                }
+                if (!document.collections.includes(collectionData.id)) {
+                    document.collections.push(collectionData.id);
+                }
+            }
+        }
+    }
+    
+    initDocumentsTreeview(null, function() {
+        highlightCollection(collectionData.id);
+    });
+}
+
+function updateCollection(collectionData) {
+    // Find existing collection in hierarchy
+    let existingCollection = findCollection(parseInt(collectionData.id));
+    if (!existingCollection) {
+        addCollection(collectionData);
+        return;
+    }
+    
+    const oldDocumentIds = existingCollection.document_ids || [];
+    const oldParentId = existingCollection.parent ? parseInt(existingCollection.parent) : null;
+    
+    // Update basic properties
+    existingCollection.name = collectionData.name;
+    existingCollection.description = collectionData.description;
+    existingCollection.document_ids = collectionData.document_ids;
+    
+    // Handle parent change if necessary
+    const newParentId = collectionData.parent_id ? parseInt(collectionData.parent_id) : null;
+    const currentParentId = existingCollection.parent ? parseInt(existingCollection.parent) : null;
+    if (currentParentId !== newParentId) {
+        existingCollection.parent = newParentId;
+        
+        // Remove from old parent
+        if (oldParentId) {
+            const oldParent = findCollection(oldParentId);
+            if (oldParent && oldParent.children) {
+                const index = oldParent.children.findIndex(c => c.id === parseInt(collectionData.id));
+                if (index !== -1) {
+                    oldParent.children.splice(index, 1);
+                }
+            }
+        } else {
+            // Remove from root list
+            const index = collections.findIndex(c => c.id === parseInt(collectionData.id));
+            if (index !== -1) {
+                collections.splice(index, 1);
+            }
+        }
+        
+        // Add to new parent
+        if (collectionData.parent_id) {
+            const newParent = findCollection(parseInt(collectionData.parent_id));
+            if (newParent) {
+                if (!newParent.children) {
+                    newParent.children = [];
+                }
+                newParent.children.push(existingCollection);
+            } else {
+                // New parent not found, add to root level
+                const isAlreadyInRoot = collections.some(col => col.id === existingCollection.id);
+                if (!isAlreadyInRoot) {
+                    collections.push(existingCollection);
+                }
+            }
+        } else {
+            // Add to root level
+            const isAlreadyInRoot = collections.some(col => col.id === existingCollection.id);
+            if (!isAlreadyInRoot) {
+                collections.push(existingCollection);
+            }
+        }
+    }
+    
+    // Update document collections
+    // Remove from old documents
+    for (let docId of oldDocumentIds) {
+        const document = documents[docId.toString()];
+        if (document && document.collections) {
+            const index = document.collections.indexOf(parseInt(collectionData.id));
+            if (index !== -1) {
+                document.collections.splice(index, 1);
+            }
+        }
+    }
+    
+    // Add to new documents
+    if (collectionData.document_ids && collectionData.document_ids.length > 0) {
+        for (let docId of collectionData.document_ids) {
+            const document = documents[docId.toString()];
+            if (document) {
+                if (!document.collections) {
+                    document.collections = [];
+                }
+                if (!document.collections.includes(parseInt(collectionData.id))) {
+                    document.collections.push(parseInt(collectionData.id));
+                }
+            }
+        }
+    }
+    
+    initDocumentsTreeview(null, function() {
+        highlightCollection(collectionData.id);
+    });
+}
+
+function removeCollection(collectionId) {
+    // Find collection in hierarchysss
+    const collectionToRemove = findCollection(parseInt(collectionId));
+    if (!collectionToRemove) {
+        return;
+    }
+    
+    // Remove from parent or root list
+    if (collectionToRemove.parent) {
+        const parent = findCollection(parseInt(collectionToRemove.parent));
+        if (parent && parent.children) {
+            const index = parent.children.findIndex(c => c.id === parseInt(collectionId));
+            if (index !== -1) {
+                parent.children.splice(index, 1);
+            }
+        }
+    } else {
+        // Remove from root list
+        const index = collections.findIndex(c => c.id === parseInt(collectionId));
+        if (index !== -1) {
+            collections.splice(index, 1);
+        }
+    }
+    
+    // Remove from documents that belong to it
+    if (collectionToRemove.document_ids && collectionToRemove.document_ids.length > 0) {
+        for (let docId of collectionToRemove.document_ids) {
+            const document = documents[docId.toString()];
+            if (document && document.collections) {
+                const index = document.collections.indexOf(parseInt(collectionId));
+                if (index !== -1) {
+                    document.collections.splice(index, 1);
+                }
+            }
+        }
+    }
+    
+    initDocumentsTreeview(null, function() {
+        if (collectionToRemove.parent) {
+            highlightCollection(parseInt(collectionToRemove.parent));
+        }
+    });
+}
+

taguette/static/js/document/context-menu.js

@@ -0,0 +1,92 @@
+function addDocumentContextMenu() {
+    $.contextMenu({
+        selector: '.document-context-menu',
+        build: function ($trigger) {
+            const nodeId = $trigger.attr('id');
+            const documentId = extractDocumentId(nodeId);
+
+            if (!documentId) return false;
+
+            const document = documents[documentId.toString()];
+            if (!document) return false;
+
+            let items = generateDocumentContextMenuItems(document);
+
+            return {
+                callback: (key, options) => documentContextMenuAction(key, options.$trigger.attr("id")),
+                items
+            };
+        }
+    });
+}
+
+function generateDocumentContextMenuItems(document) {
+    const isFavorite = document.favorite === true;
+    const favoriteLabel = isFavorite ? gettext('Remove from Bookmarks') : gettext('Add to Bookmarks');
+    const favoriteIcon = isFavorite ? 'fas fa-star' : 'far fa-star';
+
+    const items = {
+        "edit": {
+            name: gettext('Edit document'),
+            icon: "fas fa-edit",
+            callback: (key, options) => documentContextMenuAction('edit', document.id)
+        },
+        "favorite": {
+            name: favoriteLabel,
+            icon: favoriteIcon,
+            callback: (key, options) => documentContextMenuAction('favorite', document.id)
+        },
+        "separator1": "---------",
+        "delete": {
+            name: gettext('Delete document'),
+            icon: "fas fa-trash",
+            callback: (key, options) => documentContextMenuAction('delete', document.id)
+        }
+    };
+
+    return items;
+}
+
+function documentContextMenuAction(action, param) {
+    const actionFunction = documentActions[action];
+
+    if (actionFunction) {
+        actionFunction(param);
+    } else {
+       log('No action found for:', action);
+    }
+}
+
+function toggleDocumentFavorite(documentId) {
+    const document = documents[documentId.toString()];
+    if (!document) return;
+
+    const updatedDocument = {
+        id: parseInt(documentId),
+        favorite: !document.favorite
+    };
+
+    submitDocumentUpdate(updatedDocument, function(response) {
+        updateDocumentsList();
+        initDocumentsTreeview();
+    }, function(error) {
+        log('Error updating document favorite:', 'error', error);
+    });
+}
+
+const documentActions = {
+    edit: documentId => editDocument(documentId),
+    favorite: documentId => toggleDocumentFavorite(documentId),
+    delete: documentId => deleteDocument(documentId)
+};
+
+function extractDocumentId(nodeId) {
+    if (!nodeId) return null;
+
+    const match = nodeId.match(/document-link-(\d+)/);
+    return match ? parseInt(match[1]) : null;
+}
+
+$(document).ready(function() {
+    addDocumentContextMenu();
+});

taguette/static/js/document/custom-select.js

@@ -0,0 +1,82 @@
+// Custom Select Dropdown with Toolbar Actions
+// Based on https://blog.logrocket.com/creating-custom-select-dropdown-css/
+
+// DOM Elements
+const customSelect = document.querySelector(".custom-select");
+const selectBtn = document.querySelector(".select-button");
+const selectedValue = document.querySelector(".selected-value");
+const toolbarActionButtons = document.querySelector(".toolbar-action-buttons");
+
+// Toggle dropdown on button click
+selectBtn.addEventListener("click", () => {
+    customSelect.classList.toggle("active");
+    selectBtn.setAttribute(
+        "aria-expanded",
+        selectBtn.getAttribute("aria-expanded") === "true" ? "false" : "true"
+    );
+});
+
+// Add event listeners to options
+function addEventListenerToOption() {
+    const optionsList = document.querySelectorAll(".select-dropdown li");
+
+    optionsList.forEach((option) => {
+        option.addEventListener("keyup", createHandler(option));
+        option.addEventListener("click", createHandler(option));
+    });
+}
+
+// Create event handler
+function createHandler(option) {
+    return function(e) {
+        // Handle click events
+        if (e.type === "click" && e.clientX !== 0 && e.clientY !== 0) {
+            const text = this.children[1].textContent;
+            updateSelectedValue(text);
+
+            const input = option.querySelector('input[type="radio"]');
+            const docId = input.id.split('-')[1];
+
+            linkDocument(input, docId);
+            toggleToolbarActions(true);
+            emptyTagSelection(true);
+        }
+
+        // Handle keyboard events
+        if (e.key === "Enter") {
+            const text = this.textContent;
+            updateSelectedValue(text);
+            customSelect.classList.remove("active");
+        }
+    };
+}
+
+// Update selected value
+function updateSelectedValue(text) {
+    selectedValue.textContent = text;
+    selectedValue.title = text;
+    customSelect.classList.toggle('empty', !text);
+}
+
+// Toggle toolbar actions
+function toggleToolbarActions(show = false) {
+    if(show) {
+        customSelect.classList.remove("active");
+        toolbarActionButtons.style.display = '';
+
+        if(current_document) {
+            const doc = documents[current_document];
+            updateSelectedValue(doc ? doc.name : '');
+        } else {
+            updateSelectedValue('');
+        }
+    } else {
+        toolbarActionButtons.style.setProperty('display', 'none', 'important');
+        updateSelectedValue('');
+    }
+}
+
+// Initialize event listeners
+addEventListenerToOption();
+// Toggle Toolbars actions
+toggleToolbarActions(false);