libreqda 1.2.0__py3-none-any.whl

taguette/static/js/project/search.js

@@ -0,0 +1,124 @@
+$(document).ready(function() {
+    const regEscape = v => v.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    const $formSearch = $("#form-search-documents");
+    const $inputSearch = $("#input-search-documents");
+    const $divSearchResults = $("#ul-search-results");
+    const minimumCharacters = 3;
+    let searchTimeout = null;
+
+
+    $inputSearch.keyup(function(){
+        clearTimeout(searchTimeout);
+        searchTimeout = setTimeout(function(){
+            doSearch();
+        }, 500);
+    });
+
+    $formSearch.submit(function(e){
+        e.preventDefault();
+        clearTimeout(searchTimeout);
+        doSearch();
+
+        return false;
+    });
+
+    $('button.page-selector').click(function(e) {
+        e.stopPropagation();
+        e.preventDefault();
+
+        doSearch($(this).data('page'));
+
+        return false;
+    });
+
+    function showSearchSpinner() {
+        $formSearch.addClass('searching');
+    }
+
+    function hideSearchSpinner() {
+        $formSearch.removeClass('searching');
+    }
+
+    function clearSearchContent() {
+        $divSearchResults.html('');
+    }
+
+    function doSearch(page=1) {
+        const searchText = $inputSearch.val().toLowerCase(),
+            previousPage = page - 1,
+            nextPage = page + 1;
+        log(`Search in documents '${searchText}'`);
+        $divSearchResults.html('');
+        $('button.page-selector').hide();
+        if(searchText.length < minimumCharacters) {
+            log(`Not enough characters to search documents, ${minimumCharacters} or more characters are required`)
+            return;
+        }
+
+        if(searchText !== '') {
+            showSearchSpinner();
+
+            getJSON(
+                `/api/project/${project_id}/search/${encodeURIComponent(searchText)}?page=${page}`
+            )
+                .then(function (result) {
+                    $("<li/>", {
+                        'class': "dropdown-item disabled sticky first",
+                        'html': gettext("Found in %(nb)s document(s)", {nb: result['nb_results']}) + `<span class='pagination'>${page} / ${result['pages']}</span>`
+                    }).appendTo($divSearchResults);
+                    if(result['nb_results'] > 0) {
+                        $('#btn-search-previous-page').data('page', previousPage);
+                        $('#btn-search-next-page').data('page', nextPage);
+                        if(previousPage <= 0) {
+                            $('#btn-search-previous-page').prop('disabled', true);
+                        } else {
+                            $('#btn-search-previous-page').prop('disabled', false);
+                        }
+                        log(`nextpage: ${nextPage} >= ${result['pages']}`)
+                        if(nextPage > result['pages']) {
+                            $('#btn-search-next-page').prop('disabled', true);
+                        } else {
+                            $('#btn-search-next-page').prop('disabled', false);
+                        }
+                        $('button.page-selector').show();
+                    } else {
+                        $('button.page-selector').hide();
+                    }
+                    for(let k in result['documents']) {
+                        let d = result['documents'][k];
+                        // Add document title
+                        $("<li/>", {
+                            'class': "dropdown-item disabled sticky",
+                            'text': `${d['name']} (${d['occurences']} occurrences)`
+                        }).appendTo($divSearchResults);
+
+                        // Find results and context
+                        let results = d['contents'].split(new RegExp(regEscape(result['search_text']), "ig"));
+                        for(let i=0; i<results.length-1; i++) {
+                            let start = results[i].slice(-40),
+                                end = results[i+1].slice(0, 40),
+                                a = document.createElement('a');
+                            a.className = "dropdown-item";
+                            a.innerHTML = `...${start}<span class="search-item">${result['search_text']}</span>${end}...`
+                            linkDocument(a, d['id'], null, `${result['search_text']}/${i}`);
+                            $("<li/>").append(a).appendTo($divSearchResults);
+                        }
+                    }
+
+                    // Force show
+                    if(!$("#dropdown-trigger-search").hasClass('show')) {
+                        $("#dropdown-trigger-search").dropdown('toggle');
+                    }
+                })
+                .catch(function (error) {
+                    log("Failed to search in documents", 'error', {error});
+                    showAlert(gettext("Error searching documents!"), 'error', {error})
+                })
+                .then(function (result) {
+                    hideSearchSpinner();
+                });
+        } else {
+            clearSearchContent()
+        }
+    }
+});

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

@@ -0,0 +1,133 @@
+
+function addContextMenu() {
+    $.contextMenu({
+        selector: '.tag-context-menu',
+        build: function ($trigger) {
+            const nodeId = $trigger.attr('id');
+            const node = getNode(treeview_tags, nodeId);
+
+            let items = generateContextMenuItems(node);
+
+            return {
+                callback: (key, options) => contextMenuAction(key, options.$trigger.attr("id")),
+                items
+            };
+        }
+    });
+}
+
+function generateContextMenuItems(node) {
+
+    const tagId = getTagIdFromTreeviewNode(treeview_tags, node.nodeId);
+    const tag = findTag(tagId);
+
+    const hasChildren = tag.children.length > 0;
+    const hasParent = tag.parent > 0;
+    const isExpanded = node.state.expanded;
+    const isSelected = node.state.selected;
+
+    const selectedNodes = getAllSelectedNodes(treeview_tags).length > 0;
+    const hasSelectedChildren = checkNodeHasSelectedChildren(node);
+    const hasUnselectedChildren = checkNodeHasUnselectedChildren(node);
+
+    return {
+        "toggleSelectAll": {
+            name: gettext('selectAll'),
+            icon: 'fas fa-check-square',
+            visible: hasUnselectedChildren && hasChildren,
+            callback: (key, options) => contextMenuAction('selectAll', node.nodeId)
+        },
+        "toggleDeSelectAll": {
+            name: gettext('unselectAll'),
+            icon: 'fas fa-square',
+            visible: hasChildren && hasSelectedChildren,
+            callback: (key, options) => contextMenuAction('unselectAll', node.nodeId)
+        },
+        "exploreCode": {
+            name: gettext('Explore codes'),
+            icon: 'fas fa-search',
+            callback: (key, options) => contextMenuAction('exploreCode', tagId)
+        },
+        "toggleSelect": {
+            name: gettext('Select With Condition'),
+            icon: 'fas fa-filter',
+            visible: false,
+            items: {
+                "andSelect": {
+                    name: gettext('AND'),
+                    icon: 'fas fa-plus',
+                    callback: (key, options) => contextMenuAction('selectAnd', node.nodeId)
+                },
+                "orSelect": {
+                    name: gettext('OR'),
+                    icon: 'fas fa-exchange-alt',
+                    callback: (key, options) => contextMenuAction('selectOr', node.nodeId)
+                },
+                "notSelect": {
+                    name: gettext('NOT'),
+                    icon: 'fas fa-ban',
+                    callback: (key, options) => contextMenuAction('selectNot', node.nodeId)
+                }
+            }
+        },
+        "toggleExpand": {
+            name: isExpanded ? gettext('collapse') : gettext('expand'),
+            icon: isExpanded ? 'fas fa-chevron-up' : 'fas fa-chevron-down',
+            visible: hasChildren,
+            callback: (key, options) => contextMenuAction(isExpanded ? 'collapse' : 'expand', node.nodeId)
+        },
+        "addChild": {
+            name: gettext('Add child'),
+            icon: "fas fa-plus-circle",
+            callback: (key, options) => contextMenuAction('addChild', tagId)
+        },
+        "edit": {
+            name: gettext('edit'),
+            icon: "fas fa-pen",
+            callback: (key, options) => contextMenuAction('edit', tagId)
+        },
+        "merge": {
+            name: gettext('merge'),
+            icon: "fas fa-copy",
+            callback: (key, options) => contextMenuAction('merge', tagId)
+        },
+        "deleteParent": {
+            name: gettext('deleteParent'),
+            icon: "fas fa-times-circle",
+            visible: hasParent,
+            callback: (key, options) => contextMenuAction('deleteParent', tagId)
+        },
+        "delete": {
+            name: gettext('delete'),
+            icon: "fas fa-trash",
+            callback: (key, options) => contextMenuAction('delete', tagId)
+        }
+    };
+}
+
+function contextMenuAction(action, param) {
+    const actionFunction = actions[action];
+
+    if (actionFunction) {
+        actionFunction(param);
+    } else {
+        log('No action found for:', 'warn', {action});
+    }
+}
+
+const actions = {
+    selectAll: nodeId => selectNodeAndChildren(treeview_tags, nodeId),
+    unselectAll: nodeId => unselectNodeAndChildren(treeview_tags, nodeId),
+    selectAnd: nodeId => selectWithCondition(treeview_tags, nodeId, 'and'),
+    selectOr: nodeId => selectWithCondition(treeview_tags, nodeId, 'or'),
+    selectNot: nodeId => selectWithCondition(treeview_tags, nodeId, 'not'),
+    exploreCode: tagId => openExploreCodeFromContextMenu(tagId),
+    expand: nodeId => expandNode(treeview_tags, nodeId),
+    collapse: nodeId => collapseNode(treeview_tags, nodeId),
+    unselect: nodeId => unselectNode(treeview_tags, nodeId),
+    edit: tagId => editTag(tagId),
+    addChild: tagId => createTag(false, current_selection, tagId),
+    merge: tagId => mergeTag(tagId),
+    delete: tagId => deleteTag(tagId),
+    deleteParent: tagId => removeTagParent(tagId)
+};

taguette/static/js/tag/explore-codes.js

@@ -0,0 +1,400 @@
+const treeview_tags_explore = $('#treeview-tags-explore');
+
+let exploreSelectedTags = []; // [{id, path, zone}] where zone is 'must' | 'can' | 'exclude'
+let exploreActiveZone = null;
+let appliedExploreTags = []; // last query actually applied, kept after the modal closes so it can be re-edited
+
+function initTagsExploreTreeview(filterTags = null) {
+
+    if (filterTags == null) {
+        filterTags = tags;
+    }
+
+    const treeData = convertToTreeNode(filterTags, true);
+
+    const customNodeOptions = customNodeRow(false, true, false, 'tag-node-explore-');
+
+    const options = {
+        data: treeData,
+        ...customNodeOptions,
+        showBorder: true,
+        levels: CUSTOM_LEVEL_OPTION,
+        multiSelect: true,
+    };
+
+    treeview_tags_explore.treeview(options);
+
+    treeview_tags_explore.off('nodeSelected').on('nodeSelected', function (event, node) {
+        if (!exploreSelectedTags.some(item => item.id === node.id)) {
+            exploreSelectedTags.push({
+                id: node.id,
+                path: node.text,
+                zone: exploreActiveZone
+            });
+            renderExploreZones();
+        }
+
+        // Only clear on a genuine user click, not the programmatic re-selection
+        // that happens when the tree is rebuilt (e.g. restoring selections).
+        if (!isProgrammaticSelection) {
+            clearExploreSearchFilter();
+        }
+    });
+
+    treeview_tags_explore.off('nodeUnselected').on('nodeUnselected', function (event, node) {
+        // Clicking a code that's already picked but for a different zone
+        // means "move it here", not "drop it": update its zone and put the
+        // node back in the tree so it stays checked.
+        const existing = exploreSelectedTags.find(item => item.id === node.id);
+        if (
+            !isProgrammaticSelection
+            && existing
+            && exploreActiveZone
+            && existing.zone !== exploreActiveZone
+        ) {
+            existing.zone = exploreActiveZone;
+            renderExploreZones();
+            const nodeId = getNodeIdFromTreeviewByTagId(
+                treeview_tags_explore, node.id,
+            );
+            if (nodeId !== null) {
+                selectNode(treeview_tags_explore, nodeId);
+            }
+            return;
+        }
+
+        exploreSelectedTags = exploreSelectedTags.filter(item => item.id !== node.id);
+        renderExploreZones();
+
+        // Same as nodeSelected: only clear on a genuine user click, not a
+        // programmatic unselection.
+        if (!isProgrammaticSelection) {
+            clearExploreSearchFilter();
+        }
+    });
+
+    restoreExploreSelectedNodes();
+}
+
+function clearExploreSearchFilter() {
+    const searchInput = $('#input-search-tags-explore');
+    if (searchInput.val() === '') return;
+    searchInput.val('');
+    $('#alert-tag-explore-treeview').addClass('d-none');
+    // Deferred so it runs after the treeview's own pending render (see treeview.js's similar setTimeout uses).
+    setTimeout(() => initTagsExploreTreeview(), 0);
+}
+
+function restoreExploreSelectedNodes() {
+    exploreSelectedTags.forEach(item => {
+        const nodeId = getNodeIdFromTreeviewByTagId(treeview_tags_explore, item.id);
+        if (nodeId !== null) {
+            selectNode(treeview_tags_explore, nodeId);
+        }
+    });
+}
+
+function generateExploreChipHtml(tag) {
+    const abbreviation = abbreviateTag(tag.path);
+    return `<span class="tag-badge me-2 my-1" title="${tag.path}" style="background-color: ${tag.color};">
+        ${abbreviation}
+        <button type="button" onclick="event.stopPropagation(); removeExploreChip(${tag.id})" class="tag-badge-button">x</button>
+    </span>`;
+}
+
+function renderExploreZones() {
+    const zones = {
+        must: $('#explore-zone-must-chips'),
+        can: $('#explore-zone-can-chips'),
+        exclude: $('#explore-zone-exclude-chips')
+    };
+
+    Object.keys(zones).forEach(zoneKey => {
+        const zoneTags = exploreSelectedTags.filter(item => item.zone === zoneKey);
+        if (zoneTags.length === 0) {
+            const noCodesYetLabel = gettext('No codes yet');
+            zones[zoneKey].html(`<span class="text-muted small fst-italic">${noCodesYetLabel}</span>`);
+        } else {
+            let content = '';
+            zoneTags.forEach(item => {
+                const tag = findTag(item.id);
+                if (tag) {
+                    content += generateExploreChipHtml(tag);
+                }
+            });
+            zones[zoneKey].html(content);
+        }
+    });
+
+    const hasQuery = exploreSelectedTags.some(item => item.zone === 'must' || item.zone === 'can');
+    $('#explore-codes-apply').prop('disabled', !hasQuery);
+}
+
+function removeExploreChip(tagId) {
+    const nodeId = getNodeIdFromTreeviewByTagId(treeview_tags_explore, tagId);
+    if (nodeId !== null) {
+        unselectNode(treeview_tags_explore, nodeId);
+    } else {
+        exploreSelectedTags = exploreSelectedTags.filter(item => item.id !== tagId);
+        renderExploreZones();
+    }
+}
+
+// Toggle which zone newly-clicked codes are added to. Reveals the code picker
+// (search box + codebook tree) in place; clicking the same zone's + again
+// closes it, clicking a different zone's + retargets it and flashes the
+// picker so the change in destination is noticeable.
+function toggleExploreZone(zone) {
+    const picker = $('#explore-code-picker');
+    const isOpen = !picker.hasClass('d-none');
+
+    if (isOpen && exploreActiveZone === zone) {
+        picker.addClass('d-none');
+        exploreActiveZone = null;
+        updateActiveZoneStyling();
+        return;
+    }
+
+    const zoneChanged = isOpen && exploreActiveZone !== zone;
+    exploreActiveZone = zone;
+    updateActiveZoneStyling();
+    picker.removeClass('d-none');
+
+    if (zoneChanged) {
+        flashExplorePicker();
+    }
+}
+
+function handleZoneBoxKeydown(event, zone) {
+    if (event.key === 'Enter' || event.key === ' ') {
+        event.preventDefault();
+        toggleExploreZone(zone);
+    }
+}
+
+function updateActiveZoneStyling() {
+    $('.explore-zone-box').removeClass('zone-active');
+    if (exploreActiveZone) {
+        $(`#explore-zone-${exploreActiveZone}-box`).addClass('zone-active');
+    }
+}
+
+function flashExplorePicker() {
+    const picker = document.getElementById('explore-code-picker');
+    picker.classList.remove('explore-picker-flash');
+    void picker.offsetWidth; // force reflow so the animation restarts on repeated clicks
+    picker.classList.add('explore-picker-flash');
+}
+
+function buildExploreQueryString() {
+    const must = exploreSelectedTags.filter(item => item.zone === 'must').map(item => item.path);
+    const can = exploreSelectedTags.filter(item => item.zone === 'can').map(item => item.path);
+    const exclude = exploreSelectedTags.filter(item => item.zone === 'exclude').map(item => item.path);
+
+    const mustGroup = must.join('∩');
+
+    let groups;
+    if (can.length > 0) {
+        groups = can.map(path => mustGroup ? `${mustGroup}∩${path}` : path);
+    } else {
+        groups = mustGroup ? [mustGroup] : [];
+    }
+
+    let query = groups.join('∪');
+    exclude.forEach(path => {
+        query += `¬${path}`;
+    });
+
+    return query;
+}
+
+function applyExploreQuery() {
+    const queryString = buildExploreQueryString();
+    if (!queryString) return;
+
+    const tagsSnapshot = exploreSelectedTags.slice();
+    appliedExploreTags = tagsSnapshot.map(item => ({...item}));
+
+    $('#explore-codes-modal').modal('hide');
+
+    const url = `${base_path}/project/${project_id}/highlights/${encodeURIComponent(queryString)}`;
+    window.history.pushState({tag_path: queryString}, `Tag ${queryString}`, url);
+    // Shows the progress bar animating over 600ms (vs. the brief spinner flash
+    // on a normal tag click), so applying a query reads as "computed", not a glitch.
+    loadTag(queryString, undefined, 600);
+
+    const tags_return = $('#tag-selection-return'),
+        tags_return_link = $('a', tags_return);
+    tags_return_link.unbind('click').hide();
+    tags_return_link.attr('href', url);
+    tags_return_link.bind('click', function (e) {
+        e.preventDefault();
+        if (window.history.state.tag_path === '') {
+            loadTag('');
+            selectAllTag();
+        } else {
+            window.history.back();
+        }
+        tags_return_link.hide();
+    });
+
+    showExploreQuerySummary(tagsSnapshot);
+}
+
+// Mirrors showTagSelection()'s sidebar query box, but grouped by zone since the
+// explore query's AND/OR/NOT structure can't always be expressed as the linear
+// chain that selectedTags/showTagSelection() understands.
+function showExploreQuerySummary(tagsSnapshot) {
+    const criteriaArea = $('#tag-selection-criteria-area');
+
+    const zoneLabels = {
+        can: gettext('Can use'),
+        must: gettext('Must use'),
+        exclude: gettext('Exclude')
+    };
+
+    const editSelectionLabel = gettext('Edit selection');
+    const clearSelectionLabel = gettext('Clear selection');
+    let content = '<div class="d-flex justify-content-center gap-3 explore-query-actions">';
+    content += `<span id="edit-selection" onclick="editExploreQuery()" style="cursor:pointer;">` +
+        `<i class="fas fa-pen" aria-hidden="true" title="${editSelectionLabel}"></i></span>`;
+    content += `<span id="clear-selection" onclick="clearExploreQuerySelection()" style="cursor:pointer;">` +
+        `<i class="fa fa-times" aria-hidden="true" title="${clearSelectionLabel}"></i></span>`;
+    content += '</div>';
+
+    ['can', 'must', 'exclude'].forEach(zoneKey => {
+        const zoneTags = tagsSnapshot.filter(item => item.zone === zoneKey);
+        if (zoneTags.length === 0) return;
+
+        content += `<div class="mt-1"><strong style="font-size: 0.8rem;">${zoneLabels[zoneKey]}:</strong> `;
+        zoneTags.forEach(item => {
+            const tag = findTag(item.id);
+            if (tag) {
+                content += `<span title="${tag.path}" class="tag-badge me-1" style="background-color: ${tag.color};">${abbreviateTag(tag.path)}</span>`;
+            }
+        });
+        content += '</div>';
+    });
+
+    criteriaArea.html(content).show();
+}
+
+function clearExploreQuerySelection() {
+    appliedExploreTags = [];
+    const url = `${base_path}/project/${project_id}/highlights/`;
+    window.history.pushState({tag_path: ''}, 'Tag ', url);
+    $('#tag-selection-criteria-area').hide().html('');
+    hideTagReturnLink();
+    loadDocument(current_document);
+}
+
+function seedExploreModalAndOpen(tagsToSeed) {
+    exploreSelectedTags = tagsToSeed.map(item => ({...item}));
+    initTagsExploreTreeview();
+    renderExploreZones();
+    openExploreCodes();
+}
+
+// Reopen the modal with the currently applied query's zones populated, so it
+// can be tweaked and re-applied instead of having to rebuild it from scratch.
+function editExploreQuery() {
+    seedExploreModalAndOpen(appliedExploreTags);
+}
+
+// Right-click a code in the codebook tree -> "Explore codes": opens the modal
+// with that code already added to "Can use", for people who reach conditional
+// selection via the context menu rather than the toolbar button.
+function openExploreCodeFromContextMenu(tagId) {
+    const tag = findTag(tagId);
+    if (!tag) return;
+    seedExploreModalAndOpen([{id: tag.id, path: tag.path, zone: 'can'}]);
+}
+
+function resetExploreModal() {
+    exploreSelectedTags = [];
+    deselectAllNodes(treeview_tags_explore);
+    exploreActiveZone = null;
+    updateActiveZoneStyling();
+    $('#explore-code-picker').addClass('d-none').removeClass('explore-picker-flash');
+    $('#input-search-tags-explore').val('');
+    $('#alert-tag-explore-treeview').addClass('d-none');
+    initTagsExploreTreeview();
+    renderExploreZones();
+}
+
+function openExploreCodes() {
+    const modal = document.getElementById('explore-codes-modal');
+    $(modal).modal('show').drags({handle: '.modal-header'});
+}
+
+function parseExploreQueryString(queryString) {
+    if (!queryString) return [];
+
+    const parts = queryString.split('¬');
+    const head = parts[0];
+    const excludePaths = parts.slice(1).filter(Boolean);
+    const groups = head
+        ? head.split('∪').map(g => g.split('∩').filter(Boolean))
+        : [];
+
+    let mustPaths = [];
+    let canPaths = [];
+    if (groups.length === 1) {
+        mustPaths = groups[0];
+    } else if (groups.length > 1) {
+        mustPaths = groups[0].filter(p => groups.every(g => g.includes(p)));
+        const seen = new Set();
+        groups.forEach(g => g.forEach(p => {
+            if (!mustPaths.includes(p) && !seen.has(p)) {
+                seen.add(p);
+                canPaths.push(p);
+            }
+        }));
+    }
+
+    const toTag = (path, zone) => {
+        const tag = findTag(path);
+        return tag ? {id: tag.id, path: tag.path, zone} : null;
+    };
+    return [
+        ...mustPaths.map(p => toTag(p, 'must')),
+        ...canPaths.map(p => toTag(p, 'can')),
+        ...excludePaths.map(p => toTag(p, 'exclude')),
+    ].filter(Boolean);
+}
+
+function restoreExploreQueryFromUrl() {
+    const re = new RegExp(`^${escapeRegExp(base_path)}/project/[0-9]+/highlights/([^/]+)`);
+    const m = window.location.pathname.match(re);
+    if (!m) return;
+    const queryString = decodeURIComponent(m[1]);
+    const tags = parseExploreQueryString(queryString);
+    if (!tags.length) return;
+    appliedExploreTags = tags;
+    showExploreQuerySummary(tags);
+}
+
+$(document).ready(function () {
+    initTagsExploreTreeview();
+    renderExploreZones();
+    restoreExploreQueryFromUrl();
+
+    document.getElementById('input-search-tags-explore').addEventListener('input', function () {
+        const filterText = $(this).val().toLowerCase();
+        const filteredTags = handleSearch(filterText);
+        initTagsExploreTreeview(filteredTags);
+
+        const alert_explore_treeview = $('#alert-tag-explore-treeview');
+        if (filteredTags.length === 0) {
+            alert_explore_treeview.removeClass('d-none').html(`<strong>${TAG_NOT_FOUND_MESSAGE}</strong>`);
+        } else {
+            alert_explore_treeview.addClass('d-none');
+        }
+    });
+
+    document.getElementById('explore-codes-apply').addEventListener('click', applyExploreQuery);
+
+    $('#explore-codes-modal').on('hidden.bs.modal', resetExploreModal);
+
+    enableTypeToFocusSearch('#explore-codes-modal', '#input-search-tags-explore');
+});