[Enhancement kbss-cvut/termit-ui#520] Change record filtering

src/main/java/cz/cvut/kbss/termit/dto/filter/ChangeRecordFilterDto.java

@@ -0,0 +1,106 @@
+package cz.cvut.kbss.termit.dto.filter;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import cz.cvut.kbss.termit.util.Utils;
+
+import java.net.URI;
+import java.util.Objects;
+
+/**
+ * Represents parameters for filtering vocabulary content changes.
+ */
+public class ChangeRecordFilterDto {
+    private String assetLabel = "";
+    private String changedAttributeName = "";
+    private String authorName = "";
+    private URI changeType = null;
+
+    public ChangeRecordFilterDto() {
+    }
+
+    public ChangeRecordFilterDto(String changedAttributeName, String authorName, URI changeType) {
+        this.changedAttributeName = changedAttributeName;
+        this.authorName = authorName;
+        this.changeType = changeType;
+    }
+
+    public ChangeRecordFilterDto(String assetLabel, String changedAttributeName, String authorName, URI changeType) {
+        this.assetLabel = assetLabel;
+        this.changedAttributeName = changedAttributeName;
+        this.authorName = authorName;
+        this.changeType = changeType;
+    }
+
+    public String getAssetLabel() {
+        return assetLabel;
+    }
+
+    public void setAssetLabel(String assetLabel) {
+        this.assetLabel = assetLabel;
+    }
+
+    public String getChangedAttributeName() {
+        return changedAttributeName;
+    }
+
+    public void setChangedAttributeName(String changedAttributeName) {
+        this.changedAttributeName = changedAttributeName;
+    }
+
+    public String getAuthorName() {
+        return authorName;
+    }
+
+    public void setAuthorName(String authorName) {
+        this.authorName = authorName;
+    }
+
+    public URI getChangeType() {
+        return changeType;
+    }
+
+    public void setChangeType(URI changeType) {
+        this.changeType = changeType;
+    }
+
+    /**
+     * @return true when all attributes are empty or null
+     */
+    @JsonIgnore
+    public boolean isEmpty() {
+        return Utils.isBlank(assetLabel) &&
+                Utils.isBlank(changedAttributeName) &&
+                Utils.isBlank(authorName) &&
+                changeType == null;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof ChangeRecordFilterDto that)) return false;
+        return Objects.equals(assetLabel, that.assetLabel) &&
+                Objects.equals(changedAttributeName, that.changedAttributeName) &&
+                Objects.equals(authorName, that.authorName) &&
+                Objects.equals(changeType, that.changeType);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(assetLabel, changedAttributeName, authorName, changeType);
+    }
+
+
+    /**
+     * Constants for the Open API documentation of the REST API.
+     */
+    public static final class ApiDoc {
+        public static final String TERM_NAME_DESCRIPTION = "Name of the term used for filtering.";
+        public static final String CHANGE_TYPE_DESCRIPTION = "Type of the change used for filtering.";
+        public static final String AUTHOR_NAME_DESCRIPTION = "Name of the author of the change used for filtering.";
+        public static final String CHANGED_ATTRIBUTE_DESCRIPTION = "Name of the changed attribute used for filtering.";
+
+        private ApiDoc() {
+            throw new AssertionError();
+        }
+    }
+}

src/main/java/cz/cvut/kbss/termit/persistence/dao/TermDao.java

@@ -91,23 +91,23 @@ protected URI labelProperty() {
     @Override
     public Optional<Term> find(URI id) {
         try {
-            final Optional<Term> result = Optional.ofNullable(
-                    em.find(Term.class, id, descriptorFactory.termDescriptor(resolveVocabularyId(id))));
+            final Optional<Term> result = resolveVocabularyId(id).map(vocabulary ->
+                    em.find(Term.class, id, descriptorFactory.termDescriptor(vocabulary)));
             result.ifPresent(this::postLoad);
             return result;
         } catch (RuntimeException e) {
             throw new PersistenceException(e);
         }
     }
 
-    private URI resolveVocabularyId(URI termId) {
+    private Optional<URI> resolveVocabularyId(URI termId) {
         try {
-            return em.createNativeQuery("SELECT DISTINCT ?v WHERE { ?t ?inVocabulary ?v . }", URI.class)
+            return Optional.of(em.createNativeQuery("SELECT DISTINCT ?v WHERE { ?t ?inVocabulary ?v . }", URI.class)
                      .setParameter("t", termId)
                      .setParameter("inVocabulary", TERM_FROM_VOCABULARY)
-                     .getSingleResult();
+                     .getSingleResult());
         } catch (NoResultException | NoUniqueResultException e) {
-            throw new PersistenceException("Unable to resolve term vocabulary.", e);
+            return Optional.empty();
         }
     }
 

src/main/java/cz/cvut/kbss/termit/persistence/dao/VocabularyDao.java

@@ -19,7 +19,6 @@
 
 import cz.cvut.kbss.jopa.model.EntityManager;
 import cz.cvut.kbss.jopa.model.query.Query;
-import cz.cvut.kbss.jopa.model.query.TypedQuery;
 import cz.cvut.kbss.jopa.vocabulary.DC;
 import cz.cvut.kbss.jopa.vocabulary.SKOS;
 import cz.cvut.kbss.termit.asset.provenance.ModifiesData;
@@ -28,6 +27,7 @@
 import cz.cvut.kbss.termit.dto.PrefixDeclaration;
 import cz.cvut.kbss.termit.dto.RdfsStatement;
 import cz.cvut.kbss.termit.dto.Snapshot;
+import cz.cvut.kbss.termit.dto.filter.ChangeRecordFilterDto;
 import cz.cvut.kbss.termit.event.AssetPersistEvent;
 import cz.cvut.kbss.termit.event.AssetUpdateEvent;
 import cz.cvut.kbss.termit.event.BeforeAssetDeleteEvent;
@@ -43,6 +43,7 @@
 import cz.cvut.kbss.termit.model.validation.ValidationResult;
 import cz.cvut.kbss.termit.persistence.context.DescriptorFactory;
 import cz.cvut.kbss.termit.persistence.context.VocabularyContextMapper;
+import cz.cvut.kbss.termit.persistence.dao.changetracking.ChangeRecordDao;
 import cz.cvut.kbss.termit.persistence.snapshot.AssetSnapshotLoader;
 import cz.cvut.kbss.termit.persistence.validation.VocabularyContentValidator;
 import cz.cvut.kbss.termit.service.snapshot.SnapshotProvider;
@@ -88,6 +89,7 @@ public class VocabularyDao extends BaseAssetDao<Vocabulary>
             "} GROUP BY ?date HAVING (?cnt > 0) ORDER BY ?date";
 
     private static final String REMOVE_GLOSSARY_TERMS_QUERY_FILE = "remove/removeGlossaryTerms.ru";
+    private final ChangeRecordDao changeRecordDao;
 
     private volatile long lastModified;
 
@@ -97,11 +99,13 @@ public class VocabularyDao extends BaseAssetDao<Vocabulary>
 
     @Autowired
     public VocabularyDao(EntityManager em, Configuration config, DescriptorFactory descriptorFactory,
-                         VocabularyContextMapper contextMapper, ApplicationContext context) {
+                         VocabularyContextMapper contextMapper, ApplicationContext context,
+                         ChangeRecordDao changeRecordDao) {
         super(Vocabulary.class, em, config.getPersistence(), descriptorFactory);
         this.contextMapper = contextMapper;
         refreshLastModified();
         this.context = context;
+        this.changeRecordDao = changeRecordDao;
     }
 
     @Override
@@ -405,34 +409,9 @@ public List<AggregatedChangeInfo> getChangesOfContent(Vocabulary vocabulary) {
      * @param pageReq    Specification of the size and number of the page to return
      * @return List of change records, ordered by date in descending order
      */
-    public List<AbstractChangeRecord> getDetailedHistoryOfContent(Vocabulary vocabulary, Pageable pageReq) {
+    public List<AbstractChangeRecord> getDetailedHistoryOfContent(Vocabulary vocabulary, ChangeRecordFilterDto filter, Pageable pageReq) {
         Objects.requireNonNull(vocabulary);
-        return createDetailedContentChangesQuery(vocabulary, pageReq).getResultList();
-    }
-
-    private TypedQuery<AbstractChangeRecord> createDetailedContentChangesQuery(Vocabulary vocabulary,
-                                                                               Pageable pageReq) {
-        return em.createNativeQuery("""
-                                            SELECT ?record WHERE {
-                                                ?term ?inVocabulary ?vocabulary ;
-                                                    a ?termType .
-                                                ?record a ?changeRecord ;
-                                                    ?relatesTo ?term ;
-                                                    ?hasTime ?timestamp .
-                                                OPTIONAL { ?record ?hasChangedAttribute ?attribute . }
-                                            } ORDER BY DESC(?timestamp) ?attribute
-                                            """, AbstractChangeRecord.class)
-                 .setParameter("inVocabulary",
-                               URI.create(cz.cvut.kbss.termit.util.Vocabulary.s_p_je_pojmem_ze_slovniku))
-                 .setParameter("vocabulary", vocabulary)
-                 .setParameter("termType", URI.create(SKOS.CONCEPT))
-                 .setParameter("changeRecord", URI.create(cz.cvut.kbss.termit.util.Vocabulary.s_c_zmena))
-                 .setParameter("relatesTo", URI.create(cz.cvut.kbss.termit.util.Vocabulary.s_p_ma_zmenenou_entitu))
-                 .setParameter("hasTime", URI.create(cz.cvut.kbss.termit.util.Vocabulary.s_p_ma_datum_a_cas_modifikace))
-                 .setParameter("hasChangedAttribute",
-                               URI.create(cz.cvut.kbss.termit.util.Vocabulary.s_p_ma_zmeneny_atribut))
-                 .setFirstResult((int) pageReq.getOffset())
-                 .setMaxResults(pageReq.getPageSize());
+        return changeRecordDao.findAllRelatedToType(vocabulary, filter, URI.create(SKOS.CONCEPT), pageReq);
     }
 
     private Query createContentChangesQuery(Vocabulary vocabulary) {