Examples with Pair de.catma.util.Pair used on opensource projects

Example 16 with Pair

use of de.catma.util.Pair in project catma by forTEXT.

the class TPGraphProjectHandler method ensureProjectRevisionIsLoaded.

@Override
public void ensureProjectRevisionIsLoaded(ExecutionListener<TagManager> openProjectListener, ProgressListener progressListener, String revisionHash, final TagManager tagManager, Supplier<List<TagsetDefinition>> tagsetsSupplier, Supplier<List<SourceDocument>> documentsSupplier, CollectionsSupplier collectionsSupplier, boolean forceGraphReload, BackgroundService backgroundService) throws Exception {
    logger.info(String.format("Checking if Project %1$s with revision %2$s is present in the graph", projectReference.getProjectId(), revisionHash));
    GraphTraversalSource g = graph.traversal();
    if (forceGraphReload || !g.V().has(nt(ProjectRevision), "revisionHash", revisionHash).hasNext()) {
        logger.info(String.format("Loading Project %1$s with revision %2$s into the graph", projectReference.getProjectId(), revisionHash));
        ((TinkerGraph) graph).clear();
        backgroundService.submit(new GraphLoadJob(graph, projectReference, tagManager, user, revisionHash, tagsetsSupplier, documentsSupplier, collectionsSupplier, fileInfoProvider), new ExecutionListener<Pair<TagManager, Graph>>() {

            @Override
            public void done(Pair<TagManager, Graph> result) {
                graph = result.getSecond();
                openProjectListener.done(result.getFirst());
            }

            @Override
            public void error(Throwable t) {
                openProjectListener.error(t);
            }
        }, progressListener);
    } else {
        logger.info(String.format("Project %1$s with revision %2$s already present in the graph", projectReference.getProjectId(), revisionHash));
        openProjectListener.done(tagManager);
    }
}

Example 17 with Pair

use of de.catma.util.Pair in project catma by forTEXT.

the class GraphLoadJob method call.

@Override
public Pair<TagManager, Graph> call() throws Exception {
    getProgressListener().setProgress("Start loading project %1$s...", projectReference.getName());
    logger.info("Start loading " + projectReference.getName() + " " + projectReference.getProjectId());
    Vertex userV = graph.addVertex(nt(User));
    userV.property("userId", user.getIdentifier());
    Vertex projectV = graph.addVertex(nt(Project));
    projectV.property("propertyId", projectReference.getProjectId());
    userV.addEdge(rt(hasProject), projectV);
    Vertex projectRevV = graph.addVertex(nt(ProjectRevision));
    projectRevV.property("revisionHash", revisionHash);
    projectV.addEdge(rt(hasRevision), projectRevV);
    List<TagsetDefinition> tagsets = tagsetsSupplier.get();
    getProgressListener().setProgress("Loading Tagsets...");
    tagManager.load(tagsets);
    for (TagsetDefinition tagset : tagsets) {
        getProgressListener().setProgress("Indexing Tagset %1$s...", tagset.getName());
        Vertex tagsetV = graphWriter.addTagset(projectRevV, tagset);
        graphWriter.addHasParentRelations(tagsetV, tagset);
    }
    final List<SourceDocument> documents = documentsSupplier.get();
    for (SourceDocument document : documents) {
        getProgressListener().setProgress("Indexing Document %1$s...", document.toString());
        graphWriter.addDocument(projectRevV, document);
    }
    final List<AnnotationCollection> collections = collectionsSupplier.get(tagManager.getTagLibrary());
    for (AnnotationCollection collection : collections) {
        getProgressListener().setProgress("Indexing Collection %1$s...", collection.toString());
        graphWriter.addCollection(revisionHash, revisionHash, collection);
    }
    getProgressListener().setProgress("Finished loading project %1$s", projectReference.getName());
    logger.info("Finished loading " + projectReference.getName() + " " + projectReference.getProjectId());
    return new Pair<>(tagManager, graph);
}

Example 18 with Pair

use of de.catma.util.Pair in project catma by forTEXT.

the class AnnotationPanel method initListeners.

private void initListeners() {
    tagChangedListener = new PropertyChangeListener() {

        @SuppressWarnings("unchecked")
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            Object newValue = evt.getNewValue();
            Object oldValue = evt.getOldValue();
            if (oldValue == null) {
                // created
                Pair<TagsetDefinition, TagDefinition> value = (Pair<TagsetDefinition, TagDefinition>) newValue;
                TagsetDefinition tagset = value.getFirst();
                TagDefinition tag = value.getSecond();
                if (tag.getParentUuid().isEmpty()) {
                    Optional<TagsetTreeItem> optionalTagsetItem = findItem(tagset.getUuid());
                    optionalTagsetItem.ifPresent(tagsetItem -> {
                        if (tagsetData.contains(tagsetItem)) {
                            tagsetData.addItem(tagsetItem, new TagDataItem(tag));
                            tagsetDataProvider.refreshAll();
                            tagsetGrid.expand(tagsetItem);
                        }
                    });
                } else {
                    TagDefinition parentTag = project.getTagManager().getTagLibrary().getTagDefinition(tag.getParentUuid());
                    Optional<TagsetTreeItem> optionalParentTagItem = findItem(parentTag.getUuid());
                    optionalParentTagItem.ifPresent(parentTagItem -> {
                        if (tagsetData.contains(parentTagItem)) {
                            tagsetData.addItem(parentTagItem, new TagDataItem(tag));
                            tagsetDataProvider.refreshAll();
                            tagsetGrid.expand(parentTagItem);
                        }
                    });
                }
            } else if (newValue == null) {
                // removed
                Pair<TagsetDefinition, TagDefinition> deleted = (Pair<TagsetDefinition, TagDefinition>) oldValue;
                TagDefinition deletedTag = deleted.getSecond();
                Optional<TagsetTreeItem> optionalDeletedItem = findItem(deletedTag.getUuid());
                optionalDeletedItem.ifPresent(deletedItem -> {
                    if (tagsetData.contains(deletedItem)) {
                        tagsetData.removeItem(deletedItem);
                        tagsetDataProvider.refreshAll();
                        tagsetGrid.deselect(deletedItem);
                    }
                });
            } else {
                // update
                TagDefinition tag = (TagDefinition) newValue;
                TagsetDefinition tagset = (TagsetDefinition) oldValue;
                Optional<TagsetTreeItem> optionalTagsetItem = findItem(tagset.getUuid());
                optionalTagsetItem.ifPresent(tagsetItem -> {
                    if (tagsetData.contains(tagsetItem)) {
                        Optional<TagsetTreeItem> optionalTagDataItem = findItem((TagsetDataItem) tagsetItem, tag.getUuid());
                        optionalTagDataItem.ifPresent(tagDataItem -> {
                            TagsetTreeItem parent = tagsetData.getParent(tagDataItem);
                            tagsetData.removeItem(tagDataItem);
                            ((TagDataItem) tagDataItem).setPropertiesExpanded(true);
                            tagsetData.addItem(parent, tagDataItem);
                            // TODO: sort
                            tagsetDataProvider.refreshAll();
                            showExpandedProperties(((TagDataItem) tagDataItem));
                        });
                    }
                });
            }
        }
    };
    project.getTagManager().addPropertyChangeListener(TagManagerEvent.tagDefinitionChanged, tagChangedListener);
    propertyDefinitionChangedListener = new PropertyChangeListener() {

        @SuppressWarnings("unchecked")
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            Object newValue = evt.getNewValue();
            Object oldValue = evt.getOldValue();
            TagDefinition tag = null;
            if (oldValue == null) {
                // created
                Pair<PropertyDefinition, TagDefinition> newData = (Pair<PropertyDefinition, TagDefinition>) newValue;
                tag = newData.getSecond();
            } else if (newValue == null) {
                // removed
                Pair<PropertyDefinition, Pair<TagDefinition, TagsetDefinition>> oldData = (Pair<PropertyDefinition, Pair<TagDefinition, TagsetDefinition>>) oldValue;
                tag = oldData.getSecond().getFirst();
            } else {
                // update
                tag = (TagDefinition) oldValue;
            }
            Optional<TagsetTreeItem> optionalParentItem = Optional.empty();
            if (tag.getParentUuid().isEmpty()) {
                optionalParentItem = findItem(project.getTagManager().getTagLibrary().getTagsetDefinition(tag.getTagsetDefinitionUuid()).getUuid());
            } else {
                optionalParentItem = findItem(project.getTagManager().getTagLibrary().getTagDefinition(tag.getParentUuid()).getUuid());
            }
            if (optionalParentItem.isPresent()) {
                TagsetTreeItem parentItem = optionalParentItem.get();
                final String tagId = tag.getUuid();
                tagsetData.getChildren(parentItem).stream().filter(tagsetTreeItem -> tagsetTreeItem instanceof TagDataItem).map(tagsetTreeItem -> (TagDataItem) tagsetTreeItem).filter(tagDataItem -> tagDataItem.getTag().getUuid().equals(tagId)).findFirst().ifPresent(tagDataItem -> {
                    tagsetDataProvider.refreshItem(tagDataItem);
                    tagDataItem.setPropertiesExpanded(false);
                    hideExpandedProperties(tagDataItem);
                    tagDataItem.setPropertiesExpanded(true);
                    showExpandedProperties(tagDataItem);
                });
            }
            tagsetDataProvider.refreshAll();
            tagsetGrid.deselectAll();
        }
    };
    project.getTagManager().addPropertyChangeListener(TagManagerEvent.userPropertyDefinitionChanged, propertyDefinitionChangedListener);
}

Example 19 with Pair

use of de.catma.util.Pair in project catma by forTEXT.

the class AnnotationPanel method handleAddTagRequest.

private void handleAddTagRequest() {
    final Optional<TagsetDefinition> selectedTagset = tagsetGrid.getSelectedItems().stream().filter(tagsetTreeItem -> tagsetTreeItem instanceof TagsetDataItem).findFirst().map(tagsetTreeItem -> ((TagsetDataItem) tagsetTreeItem).getTagset());
    if (selectedTagset.isPresent() && !project.hasPermission(project.getRoleForTagset(selectedTagset.get().getUuid()), RBACPermission.TAGSET_WRITE)) {
        Notification.show("Info", String.format("You do not have the permission to make changes to Tagset %1$s, " + "Please contact the Project maintainer!", selectedTagset.get().getName()), Type.HUMANIZED_MESSAGE);
        return;
    }
    if (tagsets.isEmpty()) {
        if (project.isAuthorizedOnProject(RBACPermission.TAGSET_CREATE_OR_UPLOAD)) {
            Notification.show("Info", "You do not have any Tagsets to add Tags to yet, please create a Tagset first!", Type.HUMANIZED_MESSAGE);
        } else {
            Notification.show("Info", "You do not have any Tagsets to add Tags to yet, please contact the Project maintainer!", Type.HUMANIZED_MESSAGE);
        }
        return;
    }
    List<TagsetDefinition> editableTagsets = tagsets.stream().filter(tagset -> project.hasPermission(project.getRoleForTagset(tagset.getUuid()), RBACPermission.TAGSET_WRITE)).collect(Collectors.toList());
    if (editableTagsets.isEmpty()) {
        Notification.show("Info", "You do not have the permission to make changes to any of the available Tagsets! " + "Please contact the Project maintainer for changes!", Type.HUMANIZED_MESSAGE);
        return;
    }
    AddParenttagDialog addTagDialog = new AddParenttagDialog(editableTagsets, selectedTagset, new SaveCancelListener<Pair<TagsetDefinition, TagDefinition>>() {

        @Override
        public void savePressed(Pair<TagsetDefinition, TagDefinition> result) {
            project.getTagManager().addTagDefinition(result.getFirst(), result.getSecond());
        }
    });
    addTagDialog.show();
}

Example 20 with Pair

use of de.catma.util.Pair in project catma by forTEXT.

the class TaggerView method initListeners.

private void initListeners() {
    this.tagReferencesChangedListener = new PropertyChangeListener() {

        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getNewValue() != null) {
                @SuppressWarnings("unchecked") Pair<AnnotationCollection, List<TagReference>> changeValue = (Pair<AnnotationCollection, List<TagReference>>) evt.getNewValue();
                List<TagReference> tagReferences = changeValue.getSecond();
                List<TagReference> relevantTagReferences = new ArrayList<TagReference>();
                for (TagReference tr : tagReferences) {
                    if (isRelevantTagReference(tr, userMarkupCollectionManager.getUserMarkupCollections())) {
                        relevantTagReferences.add(tr);
                    }
                }
                tagger.setVisible(relevantTagReferences, true);
                Set<String> tagInstanceUuids = new HashSet<String>();
                for (TagReference tr : relevantTagReferences) {
                    tagInstanceUuids.add(tr.getTagInstance().getUuid());
                }
                tagInstanceUuids.forEach(annotationId -> tagger.updateAnnotation(annotationId));
            } else if (evt.getOldValue() != null) {
                @SuppressWarnings("unchecked") Pair<String, Collection<String>> changeValue = (Pair<String, Collection<String>>) evt.getOldValue();
                String collectionId = changeValue.getFirst();
                Collection<String> annotationIds = changeValue.getSecond();
                if (userMarkupCollectionManager.contains(collectionId)) {
                    userMarkupCollectionManager.removeTagInstance(annotationIds, false);
                }
                tagger.removeTagInstances(annotationIds);
                annotationPanel.removeAnnotations(annotationIds);
            }
        }
    };
    project.addPropertyChangeListener(RepositoryChangeEvent.tagReferencesChanged, tagReferencesChangedListener);
    annotationPropertiesChangedListener = new PropertyChangeListener() {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            TagInstance tagInstance = (TagInstance) evt.getOldValue();
            tagger.updateAnnotation(tagInstance.getUuid());
        }
    };
    project.addPropertyChangeListener(RepositoryChangeEvent.propertyValueChanged, annotationPropertiesChangedListener);
    tagChangedListener = new PropertyChangeListener() {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            Object newValue = evt.getNewValue();
            Object oldValue = evt.getOldValue();
            if (oldValue == null) {
            // created
            // noop
            } else if (newValue == null) {
                // removed
                @SuppressWarnings("unchecked") Pair<TagsetDefinition, TagDefinition> deleted = (Pair<TagsetDefinition, TagDefinition>) oldValue;
                for (AnnotationCollectionReference ref : userMarkupCollectionManager.getCollections(deleted.getSecond())) {
                    setAnnotationCollectionSelected(ref, false);
                    setAnnotationCollectionSelected(ref, true);
                }
            } else {
                // update
                TagDefinition tag = (TagDefinition) newValue;
                for (AnnotationCollection collection : userMarkupCollectionManager.getUserMarkupCollections()) {
                    List<TagReference> relevantTagReferences = collection.getTagReferences(tag);
                    tagger.setVisible(relevantTagReferences, false);
                    tagger.setVisible(relevantTagReferences, true);
                }
            }
        }
    };
    project.getTagManager().addPropertyChangeListener(TagManagerEvent.tagDefinitionChanged, tagChangedListener);
}