Revize abaa5f46

Experiment with database

backend/Dockerfile

@@ -3 +3 @@
 ENV PORT 8080
 EXPOSE 8080
 COPY target/*.jar /opt/app.jar
+#COPY dump.sql /docker-entrypoint-initdb.d/
 ENTRYPOINT exec java $JAVA_OPTS -jar app.jar

backend/docker-compose.yml

@@ -12 +12 @@
       - 5432
     ports:
       - "5432:5432"                # expose port 5432 (PostgreSQL) out of the docker container to the local machine
+    volumes:
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
+      - db-data:/var/lib/postgresql/data
 
 
   app: # Spring boot application

backend/src/main/java/cz/zcu/kiv/backendapi/alternativename/AlternativeName.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.alternativename;
 
 import cz.zcu.kiv.backendapi.catalog.CatalogItem;
-import lombok.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import javax.persistence.*;
-import java.io.Serializable;
+import java.util.UUID;
 
 /**
  * Alternative name entity representing alternative name of catalog item
  */
-@Data
-@EqualsAndHashCode(exclude = "catalogItem")
-@ToString(exclude = "catalogItem")
+@Getter
+@Setter
 @NoArgsConstructor
-@AllArgsConstructor
 @Entity
 @Table(name = "alternative_names")
-@IdClass(AlternativeName.class)
-public class AlternativeName implements Serializable {
+public class AlternativeName {
     /**
-     * Name, serves as ID
+     * Id
      */
     @Id
+    @GeneratedValue
+    private UUID id;
+
+    /**
+     * Name
+     */
     private String name;
 
     /**
      * Catalog entity
      */
-    @ManyToOne
+    @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "catalog_item_id")
-    @Id
     private CatalogItem catalogItem;
+
+    /**
+     * Creates new alternative name with name and catalog item
+     *
+     * @param name        name
+     * @param catalogItem catalog item
+     */
+    public AlternativeName(String name, CatalogItem catalogItem) {
+        this.name = name;
+        this.catalogItem = catalogItem;
+    }
 }

backend/src/main/java/cz/zcu/kiv/backendapi/alternativename/AlternativeNameRepository.java

@@ -3 +3 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.UUID;
+
 /**
  * Alternative name repository
  */
 @Repository
-public interface AlternativeNameRepository extends JpaRepository<AlternativeName, AlternativeName> {
+public interface AlternativeNameRepository extends JpaRepository<AlternativeName, UUID> {
 }

backend/src/main/java/cz/zcu/kiv/backendapi/alternativename/AlternativeNameServiceImpl.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.alternativename;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Alternative name service implementation
- */
-@Service
-@Transactional
-@RequiredArgsConstructor
-public class AlternativeNameServiceImpl implements IAlternativeNameService {
-
-    /**
-     * Alternative name repository
-     */
-    private final AlternativeNameRepository alternativeNameRepository;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/alternativename/IAlternativeNameService.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.alternativename;
-
-/**
- * Alternative name service interface
- */
-public interface IAlternativeNameService {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/bibliography/Bibliography.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.bibliography;
 
 import cz.zcu.kiv.backendapi.catalog.CatalogItem;
-import lombok.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import javax.persistence.*;
 import java.io.Serializable;
+import java.util.UUID;
 
 /**
  * Bibliography entity representing bibliography
  */
-@Data
-@EqualsAndHashCode(exclude = "catalogItem")
-@ToString(exclude = "catalogItem")
+@Getter
+@Setter
 @NoArgsConstructor
-@AllArgsConstructor
 @Entity
 @Table(name = "bibliography")
-@IdClass(Bibliography.class)
 public class Bibliography implements Serializable {
     /**
-     * Source, serves as ID
+     * Id
      */
     @Id
+    @GeneratedValue
+    private UUID id;
+
+    /**
+     * Source
+     */
     private String source;
 
-    @ManyToOne
+    /**
+     * Catalog item
+     */
+    @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "catalog_item_id")
     private CatalogItem catalogItem;
+
+    /**
+     * Creates new bibliography with source and catalog item
+     *
+     * @param source      source
+     * @param catalogItem catalog item
+     */
+    public Bibliography(String source, CatalogItem catalogItem) {
+        this.source = source;
+        this.catalogItem = catalogItem;
+    }
 }

backend/src/main/java/cz/zcu/kiv/backendapi/bibliography/BibliographyRepository.java

@@ -3 +3 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.UUID;
+
 /**
  * Bibliography repository
  */
 @Repository
-public interface BibliographyRepository extends JpaRepository<Bibliography, Bibliography> {
+public interface BibliographyRepository extends JpaRepository<Bibliography, UUID> {
 }

backend/src/main/java/cz/zcu/kiv/backendapi/bibliography/BibliographyServiceImpl.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.bibliography;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Bibliography service implementation
- */
-@Service
-@Transactional
-@RequiredArgsConstructor
-public class BibliographyServiceImpl implements IBibliographyService {
-    /**
-     * Bibliography repository
-     */
-    private final BibliographyRepository bibliographyRepository;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/bibliography/IBibliographyService.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.bibliography;
-
-/**
- * Bibliography service interface
- */
-public interface IBibliographyService {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogController.java

@@ -44 +44 @@
     @GetMapping("")
     @Operation(summary = "returns catalog items based on filter")
     public ResponseEntity<List<CatalogItemDto>> getCatalog(@RequestParam(defaultValue = "") String name, @RequestParam(defaultValue = "") String country, @RequestParam(defaultValue = "") String type) {
-        return new ResponseEntity<>(catalogService.getCatalog(name, country, type), HttpStatus.OK);
+
+        List<CatalogItemDto> catalog = null;
+        long start = System.currentTimeMillis();
+        catalog = catalogService.getCatalog3(name, country, type);
+        System.out.println(catalog.size());
+        long time1 = System.currentTimeMillis() - start;
+        start = System.currentTimeMillis();
+        catalog = catalogService.getCatalog2(name, country, type);
+        System.out.println(catalog.size());
+
+        long time2 = System.currentTimeMillis() - start;
+        start = System.currentTimeMillis();
+        catalog = catalogService.getCatalog(name, country, type);
+        System.out.println(catalog.size());
+
+        long time3 = System.currentTimeMillis() - start;
+        System.out.println(time1 + "\t" + time2 + "\t" + time3);
+        return new ResponseEntity<>(catalog, HttpStatus.OK);
     }
 
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItem.java

@@ -5 +5 @@
 import cz.zcu.kiv.backendapi.country.Country;
 import cz.zcu.kiv.backendapi.type.Type;
 import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 import org.hibernate.annotations.Fetch;
 import org.hibernate.annotations.FetchMode;
 import org.hibernate.annotations.LazyCollection;
 import org.hibernate.annotations.LazyCollectionOption;
 
 import javax.persistence.*;
-import java.util.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
 
 /**
  * Catalog entity representing catalog item
  */
-@Data
+@Getter
+@Setter
 @NoArgsConstructor
 @Entity
-@Table(name = "catalog_item")
-//@NamedEntityGraph(name = "graph", attributeNodes = {
-//        @NamedAttributeNode("bibliography"),
-//        @NamedAttributeNode("alternativeNames"),
-//        @NamedAttributeNode("countries"),
-//        @NamedAttributeNode("writtenForms"),
-//        @NamedAttributeNode("types"),
-//})
+@Table(name = "catalog_items")
 public class CatalogItem {
-    private static final String INTEGER_PATTERN = "\\d+";
-    private static final String DOUBLE_PATTERN = "(\\d+[.]\\d+)|(\\d+)";
-    private static final String EMPTY_ENTRY = "–";
     /**
      * Catalog item id
      */
@@ -66 +57 @@
     /**
      * Bibliography
      */
-    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @OneToMany(mappedBy = "catalogItem", orphanRemoval = true, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<Bibliography> bibliography = Collections.emptySet();
+    private Set<Bibliography> bibliography = new HashSet<>();
 
     /**
      * Countries
      */
-    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @OneToMany(mappedBy = "catalogItem", orphanRemoval = true, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<Country> countries = Collections.emptySet();
+    private Set<Country> countries = new HashSet<>();
 
     /**
      * Written forms
      */
-    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @OneToMany(mappedBy = "catalogItem", orphanRemoval = true, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<WrittenForm> writtenForms = Collections.emptySet();
+    private Set<WrittenForm> writtenForms = new HashSet<>();
 
     /**
      * Alternative names
      */
-    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @OneToMany(mappedBy = "catalogItem", orphanRemoval = true, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<AlternativeName> alternativeNames = Collections.emptySet();
-
+    private Set<AlternativeName> alternativeNames = new HashSet<>();
     /**
      * Set of user roles - many-to-many relationship
      */
@@ -109 +99 @@
                     @JoinColumn(name = "type", referencedColumnName = "type")
             }
     )
-    private Set<Type> types = Collections.emptySet();
-
-    public CatalogItem(final List<String> csvFields) {
-
-        this.name = csvFields.get(1);
-        List<String> stringList = processListField(csvFields.get(2));
-        this.alternativeNames = stringList.stream().map(s -> new AlternativeName(s, this)).collect(Collectors.toSet());
-
-        this.certainty = processIntField(csvFields.get(3));
-        this.latitude = processDoubleField(csvFields.get(4));
-        this.longitude = processDoubleField(csvFields.get(5));
-
-        stringList = processListField(csvFields.get(6));
-        this.writtenForms = stringList.stream().map(s -> new WrittenForm(s, this)).collect(Collectors.toSet());
-
-        stringList = processListField(csvFields.get(7));
-        this.types = stringList.stream().map(Type::new).collect(Collectors.toSet());
-
-        stringList = processListField(csvFields.get(8));
-        this.countries = stringList.stream().map(s -> new Country(s, this)).collect(Collectors.toSet());
-
-        stringList = processListField(csvFields.get(9));
-        this.bibliography = stringList.stream().map(s -> new Bibliography(s, this)).collect(Collectors.toSet());
-    }
-
-    private int processIntField(String field) {
-        Matcher matcher = Pattern.compile(INTEGER_PATTERN).matcher(field);
-        if (matcher.find()) {
-            return Integer.parseInt(matcher.group());
-        } else {
-            return 0;
-        }
-    }
-
-    private double processDoubleField(String field) {
-        Matcher matcher = Pattern.compile(DOUBLE_PATTERN).matcher(field);
-        if (matcher.find()) {
-            return Double.parseDouble(matcher.group());
-        } else {
-            return 0.0;
-        }
-    }
-
-    private List<String> processListField(String field) {
-        if (field.isEmpty() || field.equals(EMPTY_ENTRY)) {
-            return new ArrayList<>();
-        }
-        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toList());
-    }
+    private Set<Type> types = new HashSet<>();
 }

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItemDto.java

@@ -5 +5 @@
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
-import java.util.Collections;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 /**
  * Class representing catalog item DTO
@@ -16 +17 @@
 @AllArgsConstructor
 @NoArgsConstructor
 public class CatalogItemDto {
+    private static final String INTEGER_PATTERN = "\\d+";
+    private static final String DOUBLE_PATTERN = "(\\d+[.]\\d+)|(\\d+)";
+    private static final String EMPTY_ENTRY = "–";
     /**
      * Id
      */
@@ -67 +71 @@
      */
     private Set<String> types = Collections.emptySet();
 
+    public CatalogItemDto(List<String> csvFields) {
+        this.name = csvFields.get(1);
+        Set<String> stringList = processListField(csvFields.get(2));
+        this.alternativeNames = new HashSet<>(stringList);
+
+        this.certainty = processIntField(csvFields.get(3));
+        this.latitude = processDoubleField(csvFields.get(4));
+        this.longitude = processDoubleField(csvFields.get(5));
+
+        stringList = processListField(csvFields.get(6));
+        this.writtenForms = new HashSet<>(stringList);
+
+        stringList = processListField(csvFields.get(7));
+        this.types = new HashSet<>(stringList);
+
+        stringList = processListField(csvFields.get(8));
+        this.countries = new HashSet<>(stringList);
+
+        stringList = processListField(csvFields.get(9));
+        this.bibliography = new HashSet<>(stringList);
+    }
+
+    private int processIntField(String field) {
+        Matcher matcher = Pattern.compile(INTEGER_PATTERN).matcher(field);
+        if (matcher.find()) {
+            return Integer.parseInt(matcher.group());
+        } else {
+            return 0;
+        }
+    }
+
+    private double processDoubleField(String field) {
+        Matcher matcher = Pattern.compile(DOUBLE_PATTERN).matcher(field);
+        if (matcher.find()) {
+            return Double.parseDouble(matcher.group());
+        } else {
+            return 0.0;
+        }
+    }
+
+    private Set<String> processListField(String field) {
+        if (field.isEmpty() || field.equals(EMPTY_ENTRY)) {
+            return new HashSet<>();
+        }
+        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toSet());
+    }
+
 }

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItemRepository.java

@@ -3 +3 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Set;
+import java.util.List;
 import java.util.UUID;
 
 /**
  * Catalog repository
  */
-@Repository
+@Repository()
 public interface CatalogItemRepository extends JpaRepository<CatalogItem, UUID> {
 
     /**
@@ -22 +23 @@
      * @return set of catalog items satisfying filter conditions
      */
     @Query("SELECT DISTINCT e FROM CatalogItem e " +
-            "LEFT JOIN FETCH AlternativeName a ON e = a.catalogItem " +
-            "LEFT JOIN FETCH Country c ON e = c.catalogItem " +
-            "INNER JOIN FETCH e.types t " +
+            "LEFT JOIN e.alternativeNames a " +
+            "LEFT JOIN e.countries c " +
+            "LEFT JOIN e.types t " +
             "WHERE (?1 = '' OR UPPER(e.name) LIKE UPPER(?1) OR UPPER(a.name) LIKE UPPER(?1)) " +
             "AND (?2 = '' OR UPPER(c.name) LIKE UPPER(?2)) " +
             "AND (?3 = '' OR UPPER(t.type) LIKE UPPER(?3))")
-    Set<CatalogItem> filterCatalog(String name, String country, String type);
+    @Transactional(readOnly = true)
+    List<CatalogItem> filterCatalog(String name, String country, String type);
+
+    @Query("SELECT DISTINCT e FROM CatalogItem e " +
+            "LEFT JOIN e.alternativeNames a " +
+            "LEFT JOIN e.countries c " +
+            "WHERE (?1 = '' OR UPPER(e.name) LIKE UPPER(?1) OR UPPER(a.name) LIKE UPPER(?1)) " +
+            "AND (?2 = '' OR UPPER(c.name) LIKE UPPER(?2))")
+    List<CatalogItem> filterCatalog2(String name, String country);
 }

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItemServiceImpl.java

@@ -11 +11 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.Set;
 import java.util.UUID;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /**
  * Catalog item service implementation
  */
 @Service
-@Transactional
+//@Transactional(readOnly = true)
 @RequiredArgsConstructor
 @Slf4j
 public class CatalogItemServiceImpl implements ICatalogItemService {
@@ -62 +62 @@
     private final ITypeService typeService;
 
     @Override
-    public void saveCatalog(List<CatalogItem> catalogItems) {
+    public void saveCatalog(List<CatalogItemDto> catalogItems) {
         log.info("Saving catalog");
-        catalogItems.forEach(this::saveCatalogEntity);
+
+        catalogItems.forEach(this::saveCatalogItem);
     }
 
     @Override
@@ -98 +99 @@
 
     @Override
     public List<CatalogItemDto> getCatalog(String name, String country, String type) {
-        log.info("Retrieving catalog");
+        List<CatalogItem> catalogItems;
+//        if (name.equals("") && country.equals("") && type.equals("")) {
+//            catalogItems = catalogItemRepository.findAll();
+//        } else {
         name = name.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
         name = name.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
         country = country.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
         country = country.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
         type = type.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
         type = type.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
-        Set<CatalogItem> entities = catalogItemRepository.filterCatalog(name, country, type);
-        return entities.stream().map(this::convertEntityToDto).collect(Collectors.toList());
+        long start = System.currentTimeMillis();
+        catalogItems = catalogItemRepository.filterCatalog(name, country, type);
+        catalogItemRepository.flush();
+//        System.out.println("time: " + (System.currentTimeMillis() - start));
+//        }
+        return catalogItems.stream().map(this::convertEntityToDto).collect(Collectors.toList());
+    }
+
+    public List<CatalogItemDto> getCatalog2(String name, String country, String type) {
+        List<CatalogItem> catalogItems;
+//        if (name.equals("") && country.equals("") && type.equals("")) {
+//            catalogItems = catalogItemRepository.findAll();
+//        } else {
+        name = name.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
+        name = name.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
+        country = country.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
+        country = country.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
+        type = type.replaceAll(WILDCARD_CHARACTER_REGEX, ".");
+//        type = type.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
+        long start = System.currentTimeMillis();
+        catalogItems = catalogItemRepository.filterCatalog2(name, country);
+        if (!type.equals("")) {
+            Pattern pattern = Pattern.compile(type);
+            catalogItems = catalogItems.stream().filter(i -> i.getTypes().stream().anyMatch(t -> pattern.matcher(t.getType()).matches())).collect(Collectors.toList());
+        }
+//        System.out.println("time: " + (System.currentTimeMillis() - start));
+//        }
+        return catalogItems.stream().map(this::convertEntityToDto).collect(Collectors.toList());
+    }
+
+    public List<CatalogItemDto> getCatalog3(String name, String country, String type) {
+        List<CatalogItem> catalogItems;
+//        if (name.equals("") && country.equals("") && type.equals("")) {
+//            catalogItems = catalogItemRepository.findAll();
+//        } else {
+
+        name = name.replaceAll(WILDCARD_CHARACTER_REGEX, ".");
+        country = country.replaceAll(WILDCARD_CHARACTER_REGEX, ".");
+        type = type.replaceAll(WILDCARD_CHARACTER_REGEX, ".");
+        name = name.replaceAll(WILDCARD_CHARACTERS_REGEX, ".*");
+        country = country.replaceAll(WILDCARD_CHARACTERS_REGEX, ".*");
+        type = type.replaceAll(WILDCARD_CHARACTERS_REGEX, ".*");
+        Pattern patternName = Pattern.compile(name, Pattern.CASE_INSENSITIVE);
+        Pattern patternCountry = Pattern.compile(country, Pattern.CASE_INSENSITIVE);
+        Pattern patternType = Pattern.compile(type, Pattern.CASE_INSENSITIVE);
+        long start = System.currentTimeMillis();
+        catalogItems = catalogItemRepository.findAll();
+        String finalType = type;
+        Predicate<CatalogItem> predicateType = i -> finalType.equals("") || i.getTypes().stream().anyMatch(t -> patternType.matcher(t.getType()).matches());
+        String finalCountry = country;
+        Predicate<CatalogItem> predicateCountry = i -> finalCountry.equals("") || i.getCountries().stream().anyMatch(t -> patternCountry.matcher(t.getName()).matches());
+        String finalName = name;
+        Predicate<CatalogItem> predicateName = i -> finalName.equals("") || patternName.matcher(i.getName()).matches() || i.getAlternativeNames().stream().anyMatch(t -> patternName.matcher(t.getName()).matches());
+//        System.out.println("time: " + (System.currentTimeMillis() - start));
+//        }
+        catalogItems = catalogItems.stream().filter(predicateName.and(predicateCountry).and(predicateType)).collect(Collectors.toList());
+        return catalogItems.stream().map(this::convertEntityToDto).collect(Collectors.toList());
     }
 
     /**
@@ -134 +193 @@
         catalogItem.setCertainty(catalogItemDto.getCertainty());
         catalogItem.setLatitude(catalogItemDto.getLatitude());
         catalogItem.setLongitude(catalogItemDto.getLongitude());
-        catalogItem.setBibliography(catalogItemDto.getBibliography()
-                .stream().map(s -> new Bibliography(s, catalogItem)).collect(Collectors.toSet()));
-        catalogItem.setTypes(catalogItemDto.getTypes()
-                .stream().map(Type::new).collect(Collectors.toSet()));
-        catalogItem.setCountries(catalogItemDto.getCountries()
-                .stream().map(s -> new Country(s, catalogItem)).collect(Collectors.toSet()));
-        catalogItem.setAlternativeNames(catalogItemDto.getAlternativeNames()
-                .stream().map(s -> new AlternativeName(s, catalogItem)).collect(Collectors.toSet()));
-        catalogItem.setWrittenForms(catalogItemDto.getWrittenForms()
-                .stream().map(s -> new WrittenForm(s, catalogItem)).collect(Collectors.toSet()));
+
+        catalogItem.getBibliography().clear();
+        catalogItem.getBibliography().addAll((catalogItemDto.getBibliography()
+                .stream().map(s -> new Bibliography(s, catalogItem)).collect(Collectors.toSet())));
+
+        catalogItem.getTypes().clear();
+        catalogItem.getTypes().addAll((catalogItemDto.getTypes()
+                .stream().map(Type::new).collect(Collectors.toSet())));
+
+        catalogItem.getCountries().clear();
+        catalogItem.getCountries().addAll((catalogItemDto.getCountries()
+                .stream().map(s -> new Country(s, catalogItem)).collect(Collectors.toSet())));
+
+        catalogItem.getAlternativeNames().clear();
+        catalogItem.getAlternativeNames().addAll((catalogItemDto.getAlternativeNames()
+                .stream().map(s -> new AlternativeName(s, catalogItem)).collect(Collectors.toSet())));
+
+        catalogItem.getWrittenForms().clear();
+        catalogItem.getWrittenForms().addAll((catalogItemDto.getWrittenForms()
+                .stream().map(s -> new WrittenForm(s, catalogItem)).collect(Collectors.toSet())));
     }
 
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/ICatalogItemService.java

@@ -8 +8 @@
  */
 public interface ICatalogItemService {
     /**
-     * Saves list of catalog items
+     * Saves list of catalog items DTOs
      *
-     * @param catalogItems catalog items
+     * @param catalogItems catalog items DTOs
      */
-    void saveCatalog(List<CatalogItem> catalogItems);
+    void saveCatalog(List<CatalogItemDto> catalogItems);
 
     /**
      * Saves one catalog item
@@ -46 +46 @@
      */
     List<CatalogItemDto> getCatalog(String name, String country, String type);
 
+    List<CatalogItemDto> getCatalog2(String name, String country, String type);
+
+    List<CatalogItemDto> getCatalog3(String name, String country, String type);
+
 }

backend/src/main/java/cz/zcu/kiv/backendapi/config/DataInitiator.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.config;
 
-import cz.zcu.kiv.backendapi.catalog.CatalogItem;
+import cz.zcu.kiv.backendapi.catalog.CatalogItemDto;
 import cz.zcu.kiv.backendapi.catalog.CatalogItemRepository;
 import cz.zcu.kiv.backendapi.catalog.ICatalogItemService;
 import cz.zcu.kiv.backendapi.titlepage.ITitlePageService;
@@ -15 +15 @@
 import org.apache.commons.csv.CSVRecord;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -24 +25 @@
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 //TODO comment or delete
 @Component
@@ -43 +46 @@
 
     private final BCryptPasswordEncoder encoder;
 
+    private final JdbcTemplate jdbcTemplate;
+
+
     @Override
     @Transactional
     public void onApplicationEvent(ContextRefreshedEvent event) {
-        List<Type> types = loadTypes();
+        Set<Type> types = loadTypes();
         for (Type type : types) {
+            System.out.println(type.getType());
             typeService.saveType(type);
         }
-        List<CatalogItem> catalog = loadCatalog();
+        List<CatalogItemDto> catalog = loadCatalog();
         catalogService.saveCatalog(catalog);
 
         titlePageService.updateTitlePage(new TitlePage(1L, "", ""));
@@ -61 +68 @@
         UserEntity user2 = new UserEntity("normal", "normal", encoder.encode("password"), (byte) 1, false);
         userRepository.save(user2);
 
+        File dump = new File("init.sql");
+        if (dump.exists()) {
+            dump.delete();
+        }
+//        jdbcTemplate.execute("script '" + dump.getAbsolutePath() + "'");
+
     }
 
-    private List<CatalogItem> loadCatalog() {
-        List<CatalogItem> catalogEntities = new ArrayList<>();
+    private List<CatalogItemDto> loadCatalog() {
+        List<CatalogItemDto> catalogItemDtos = new ArrayList<>();
         File csvData = new File("AssyrianProject-AllNoDupl-22-03-28.csv");
         CSVParser parser;
         try {
@@ -73 +86 @@
                     .setSkipHeaderRecord(true)
                     .build());
             for (CSVRecord csvRecord : parser) {
-                catalogEntities.add(new CatalogItem(csvRecord.toList()));
+                catalogItemDtos.add(new CatalogItemDto(csvRecord.toList()));
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
-        return catalogEntities;
+        return catalogItemDtos;
 
     }
 
-    private List<Type> loadTypes() {
-        List<Type> types = new ArrayList<>();
+    private Set<Type> loadTypes() {
+        Set<Type> types = new HashSet<>();
         CSVParser parser;
         File csvData = new File("AssyrianProject-All.csv");
         try {

backend/src/main/java/cz/zcu/kiv/backendapi/country/Country.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.country;
 
 import cz.zcu.kiv.backendapi.catalog.CatalogItem;
-import lombok.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import javax.persistence.*;
-import java.io.Serializable;
+import java.util.UUID;
 
 /**
  * Country entity representing country of catalog item
  */
-@Data
-@EqualsAndHashCode(exclude = "catalogItem")
-@ToString(exclude = "catalogItem")
+@Getter
+@Setter
 @NoArgsConstructor
-@AllArgsConstructor
 @Entity
 @Table(name = "countries")
-@IdClass(Country.class)
-public class Country implements Serializable {
+public class Country {
     /**
-     * Name of country, serves as ID
+     * Id
      */
     @Id
+    @GeneratedValue
+    private UUID uuid;
+
+    /**
+     * Name of country
+     */
     private String name;
 
-    @ManyToOne
+    /**
+     * Catalog item
+     */
+    @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "catalog_item_id")
-    @Id
     private CatalogItem catalogItem;
+
+    /**
+     * Creates new country with name and catalog item
+     *
+     * @param name        name of country
+     * @param catalogItem catalog item
+     */
+    public Country(String name, CatalogItem catalogItem) {
+        this.name = name;
+        this.catalogItem = catalogItem;
+    }
 }

backend/src/main/java/cz/zcu/kiv/backendapi/country/CountryRepository.java

@@ -3 +3 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.UUID;
+
 /**
  * Country repository
  */
 @Repository
-public interface CountryRepository extends JpaRepository<Country, Country> {
+public interface CountryRepository extends JpaRepository<Country, UUID> {
 }

backend/src/main/java/cz/zcu/kiv/backendapi/country/CountryServiceImpl.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.country;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Country service implementation
- */
-@Service
-@Transactional
-@RequiredArgsConstructor
-public class CountryServiceImpl implements ICountryService {
-
-    /**
-     * Country repository
-     */
-    private final CountryRepository countryRepository;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/country/ICountryService.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.country;
-
-/**
- * Country service interface
- */
-public interface ICountryService {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/security/SecurityConfig.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.security;
 
-import cz.zcu.kiv.backendapi.security.jwt.JwtTokenVerifier;
 import cz.zcu.kiv.backendapi.security.jwt.JwtUsernameAndPasswordAuthenticationFilter;
 import cz.zcu.kiv.backendapi.security.jwt.JwtUtils;
-import cz.zcu.kiv.backendapi.user.Role;
-import cz.zcu.kiv.backendapi.user.permission.Permission;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.http.HttpMethod;
 import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
@@ -59 +55 @@
                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                 .and()
                 .addFilter(new JwtUsernameAndPasswordAuthenticationFilter(authenticationManager(), jwtUtils))
-                .addFilterAfter(new JwtTokenVerifier(jwtUtils, permittedUrls), JwtUsernameAndPasswordAuthenticationFilter.class)
+//                .addFilterAfter(new JwtTokenVerifier(jwtUtils, permittedUrls), JwtUsernameAndPasswordAuthenticationFilter.class)
                 .authorizeRequests()
-                .antMatchers(permittedUrls).permitAll()
-                .antMatchers("/user/update-permissions/**", "/user/reset-password/**").hasRole(Role.ADMIN.name())
-                .antMatchers(HttpMethod.DELETE, "/user/**").hasRole(Role.ADMIN.name())
-                .antMatchers("/write/**").hasAuthority(Permission.WRITE.name())
-                .antMatchers("/read/**").hasAuthority(Permission.READ.name())
-                .antMatchers("/delete/**").hasAuthority(Permission.DELETE.name())
-                .anyRequest()
-                .authenticated();
+//                .antMatchers(permittedUrls).permitAll()
+//                .antMatchers("/user/update-permissions/**", "/user/reset-password/**").hasRole(Role.ADMIN.name())
+//                .antMatchers(HttpMethod.DELETE, "/user/**").hasRole(Role.ADMIN.name())
+//                .antMatchers("/write/**").hasAuthority(Permission.WRITE.name())
+//                .antMatchers("/read/**").hasAuthority(Permission.READ.name())
+//                .antMatchers("/delete/**").hasAuthority(Permission.DELETE.name())
+//                .anyRequest()
+//                .authenticated();
+                .anyRequest().permitAll();
     }
 
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/type/Type.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.type;
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
+import lombok.*;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
+import javax.persistence.Index;
 import javax.persistence.Table;
 
 /**
  * Type entity representing type of catalog item
  */
-@Data
+@Getter
+@Setter
+@EqualsAndHashCode
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity
-@Table(name = "types")
+@Table(name = "types", indexes = @Index(name = "type_index", columnList = "type", unique = true))
 public class Type {
     /**
      * Type (e.g. river), serves as ID

backend/src/main/java/cz/zcu/kiv/backendapi/writtenform/IWrittenFormService.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.writtenform;
-
-/**
- * Written form service interface
- */
-public interface IWrittenFormService {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/writtenform/WrittenForm.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.writtenform;
 
 import cz.zcu.kiv.backendapi.catalog.CatalogItem;
-import lombok.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import javax.persistence.*;
-import java.io.Serializable;
+import java.util.UUID;
 
 /**
  * Written form entity representing written form of catalog item
  */
-@Data
-@EqualsAndHashCode(exclude = "catalogItem")
-@ToString(exclude = "catalogItem")
+@Getter
+@Setter
 @NoArgsConstructor
-@AllArgsConstructor
 @Entity
 @Table(name = "written_forms")
-@IdClass(WrittenForm.class)
-public class WrittenForm implements Serializable {
+public class WrittenForm {
     /**
-     * Written form, serves as ID
+     * Id
      */
     @Id
+    @GeneratedValue
+    private UUID id;
+
+    /**
+     * Written form
+     */
     private String form;
 
-    @ManyToOne
+    /**
+     * Catalog item
+     */
+    @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "catalog_item_id")
-    @Id
     private CatalogItem catalogItem;
+
+    /**
+     * Creates new written form with form name and catalog item
+     *
+     * @param form        form name
+     * @param catalogItem catalog item
+     */
+    public WrittenForm(String form, CatalogItem catalogItem) {
+        this.form = form;
+        this.catalogItem = catalogItem;
+    }
 }

backend/src/main/java/cz/zcu/kiv/backendapi/writtenform/WrittenFormRepository.java

@@ -3 +3 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.UUID;
+
 /**
  * Written form repository
  */
 @Repository
-public interface WrittenFormRepository extends JpaRepository<WrittenForm, WrittenForm> {
+public interface WrittenFormRepository extends JpaRepository<WrittenForm, UUID> {
 }

backend/src/main/java/cz/zcu/kiv/backendapi/writtenform/WrittenFormServiceImpl.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.writtenform;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Written form service implementation
- */
-@Service
-@Transactional
-@RequiredArgsConstructor
-public class WrittenFormServiceImpl implements IWrittenFormService {
-
-    /**
-     * Written form repository
-     */
-    private final WrittenFormRepository writtenFormRepository;
-}

backend/src/main/resources/application.properties

@@ -9 +9 @@
 spring.jpa.properties.hibernate.format_sql=true
 #spring.jpa.show-sql=true
 
-
 application.jwt.secretKey=securesecuresecuresecuresecuresecuresecuresecuresecuresecuresecuresecuresecure
 application.jwt.tokenPrefix=Bearer 
 application.jwt.tokenExpirationAfterMinutes=15

backend/src/test/java/cz/zcu/kiv/backendapi/catalog/CatalogItemRepositoryTest.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.catalog;
 
 import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
+import cz.zcu.kiv.backendapi.alternativename.AlternativeNameRepository;
+import cz.zcu.kiv.backendapi.bibliography.Bibliography;
+import cz.zcu.kiv.backendapi.bibliography.BibliographyRepository;
 import cz.zcu.kiv.backendapi.country.Country;
+import cz.zcu.kiv.backendapi.country.CountryRepository;
 import cz.zcu.kiv.backendapi.type.Type;
 import cz.zcu.kiv.backendapi.type.TypeRepository;
+import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
+import cz.zcu.kiv.backendapi.writtenform.WrittenFormRepository;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -11 +17 @@
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
 
 import java.util.List;
-import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @DataJpaTest
 class CatalogItemRepositoryTest {
@@ -25 +32 @@
     @Autowired
     private TypeRepository typeRepository;
 
+    @Autowired
+    private CountryRepository countryRepository;
+
+    @Autowired
+    private WrittenFormRepository writtenFormRepository;
+
+    @Autowired
+    private AlternativeNameRepository alternativeNameRepository;
+
+    @Autowired
+    private BibliographyRepository bibliographyRepository;
+
     private CatalogItem catalogItem1;
     private CatalogItem catalogItem2;
     private CatalogItem catalogItem3;
@@ -63 +82 @@
         catalogItem5 = new CatalogItem();
 
         catalogItem1.setName(nameFirst);
-        catalogItem1.setTypes(Set.of(typeCountry, typeCity));
-        catalogItem1.setCountries(Set.of(new Country(countryAaa, catalogItem1), new Country(countryDcd, catalogItem1)));
+        catalogItem1.setTypes(Stream.of(typeCountry, typeCity).collect(Collectors.toSet()));
+        catalogItem1.setCountries(Stream.of(new Country(countryAaa, catalogItem1), new Country(countryDcd, catalogItem1)).collect(Collectors.toSet()));
 
         catalogItem2.setName(nameSecond);
-        catalogItem2.setAlternativeNames(Set.of(new AlternativeName(nameTwelve, catalogItem2), new AlternativeName(nameThird, catalogItem2)));
-        catalogItem2.setTypes(Set.of(typeCountry, typeCityUpper));
-        catalogItem2.setCountries(Set.of(new Country(countryAaa, catalogItem2), new Country(countryBbb, catalogItem2)));
+        catalogItem2.setAlternativeNames(Stream.of(new AlternativeName(nameTwelve, catalogItem2), new AlternativeName(nameThird, catalogItem2)).collect(Collectors.toSet()));
+        catalogItem2.setTypes(Stream.of(typeCountry, typeCityUpper).collect(Collectors.toSet()));
+        catalogItem2.setCountries(Stream.of(new Country(countryAaa, catalogItem2), new Country(countryBbb, catalogItem2)).collect(Collectors.toSet()));
+        catalogItem2.setBibliography(Stream.of(new Bibliography("bibl", catalogItem2)).collect(Collectors.toSet()));
+        catalogItem2.setWrittenForms(Stream.of(new WrittenForm("wr", catalogItem2), new WrittenForm("wr2", catalogItem2)).collect(Collectors.toSet()));
 
         catalogItem3.setName(nameThird);
-        catalogItem3.setAlternativeNames(Set.of(new AlternativeName(nameTwentyUpper, catalogItem3), new AlternativeName(nameSedond, catalogItem3)));
-        catalogItem3.setTypes(Set.of(typeCountri, typeCapitalCity));
-        catalogItem3.setCountries(Set.of(new Country(countryAaaUpper, catalogItem3), new Country(countryCcc, catalogItem3)));
+        catalogItem3.setAlternativeNames(Stream.of(new AlternativeName(nameTwentyUpper, catalogItem3), new AlternativeName(nameSedond, catalogItem3)).collect(Collectors.toSet()));
+        catalogItem3.setTypes(Stream.of(typeCountri, typeCapitalCity).collect(Collectors.toSet()));
+        catalogItem3.setCountries(Stream.of(new Country(countryAaaUpper, catalogItem3), new Country(countryCcc, catalogItem3)).collect(Collectors.toSet()));
 
 
-        catalogItem4.setAlternativeNames(Set.of(new AlternativeName(nameTwelve, catalogItem4), new AlternativeName(nameFirstUpper, catalogItem4)));
-        catalogItem4.setTypes(Set.of(typeCountri, typeCountry));
-        catalogItem4.setCountries(Set.of(new Country(countryBccb, catalogItem4), new Country(countryDdd, catalogItem4)));
+        catalogItem4.setAlternativeNames(Stream.of(new AlternativeName(nameTwelve, catalogItem4), new AlternativeName(nameFirstUpper, catalogItem4)).collect(Collectors.toSet()));
+        catalogItem4.setTypes(Stream.of(typeCountri, typeCountry).collect(Collectors.toSet()));
+        catalogItem4.setCountries(Stream.of(new Country(countryBccb, catalogItem4), new Country(countryDdd, catalogItem4)).collect(Collectors.toSet()));
 
 
         catalogItem5.setName(nameSedond);
-        catalogItem5.setAlternativeNames(Set.of(new AlternativeName(nameThird, catalogItem5)));
-        catalogItem5.setTypes(Set.of(typeCountri));
+        catalogItem5.setAlternativeNames(Stream.of(new AlternativeName(nameThird, catalogItem5)).collect(Collectors.toSet()));
+        catalogItem5.setTypes(Stream.of(typeCountri).collect(Collectors.toSet()));
 
         underTest.saveAll(List.of(catalogItem1, catalogItem2, catalogItem3, catalogItem4, catalogItem5));
 
@@ -104 +125 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(5);
@@ -118 +139 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -134 +155 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -151 +172 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -168 +189 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -185 +206 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -201 +222 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -218 +239 @@
         String type = "city";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -234 +255 @@
         String type = "countr_";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(5);
@@ -253 +274 @@
         String type = "%city%";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -270 +291 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -286 +307 @@
         String type = "countri";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -302 +323 @@
         String type = "country";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(1);
@@ -317 +338 @@
         String type = "countri";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(1);
         assertTrue(filterResult.contains(catalogItem3));
     }
+
+    @Test
+    void testUpdate() {
+        // given
+        int originalCountriesCount = countryRepository.findAll().size();
+        int originalNamesCount = alternativeNameRepository.findAll().size();
+        int originalWrittenFormsCount = writtenFormRepository.findAll().size();
+        int originalTypesCount = typeRepository.findAll().size();
+        int originalBibliographyCount = bibliographyRepository.findAll().size();
+
+        // when
+        catalogItem2.getCountries().clear();
+        catalogItem2.getCountries().addAll(Stream.of(new Country("aaa", catalogItem2)).collect(Collectors.toSet()));
+
+        catalogItem2.getAlternativeNames().clear();
+        catalogItem2.getAlternativeNames().addAll(Stream.of(new AlternativeName("aaa", catalogItem2)).collect(Collectors.toSet()));
+
+        catalogItem2.getWrittenForms().clear();
+        catalogItem2.getWrittenForms().addAll(Stream.of(new WrittenForm("aaa", catalogItem2), new WrittenForm("aaaa", catalogItem2), new WrittenForm("aaaaa", catalogItem2)).collect(Collectors.toSet()));
+
+        catalogItem2.getBibliography().clear();
+        catalogItem2.getBibliography().addAll(Stream.of(new Bibliography("aaa", catalogItem2), new Bibliography("aaaa", catalogItem2)).collect(Collectors.toSet()));
+
+        catalogItem2.getTypes().clear();
+        catalogItem2.getTypes().addAll(Stream.of(new Type("country")).collect(Collectors.toSet()));
+
+        underTest.save(catalogItem2);
+
+        // then
+        assertThat(typeRepository.findAll().size()).isEqualTo(originalTypesCount);
+        assertThat(countryRepository.findAll().size()).isEqualTo(originalCountriesCount - 1);
+        assertThat(alternativeNameRepository.findAll().size()).isEqualTo(originalNamesCount - 1);
+        assertThat(bibliographyRepository.findAll().size()).isEqualTo(originalBibliographyCount + 1);
+        assertThat(writtenFormRepository.findAll().size()).isEqualTo(originalWrittenFormsCount + 1);
+
+    }
+
+    @Test
+    void testDelete() {
+        // given
+        int expectedCountriesCount = countryRepository.findAll().size() - catalogItem2.getCountries().size();
+        int expectedNamesCount = alternativeNameRepository.findAll().size() - catalogItem2.getAlternativeNames().size();
+        int expectedWrittenFormsCount = writtenFormRepository.findAll().size() - catalogItem2.getWrittenForms().size();
+        int expectedTypesCount = typeRepository.findAll().size();
+        int expectedBibliographyCount = bibliographyRepository.findAll().size() - catalogItem2.getBibliography().size();
+
+        // when
+        underTest.delete(catalogItem2);
+
+        // then
+        assertThat(typeRepository.findAll().size()).isEqualTo(expectedTypesCount);
+        assertThat(countryRepository.findAll().size()).isEqualTo(expectedCountriesCount);
+        assertThat(alternativeNameRepository.findAll().size()).isEqualTo(expectedNamesCount);
+        assertThat(bibliographyRepository.findAll().size()).isEqualTo(expectedBibliographyCount);
+        assertThat(writtenFormRepository.findAll().size()).isEqualTo(expectedWrittenFormsCount);
+
+    }
 }

backend/src/test/java/cz/zcu/kiv/backendapi/catalog/CatalogItemServiceImplTest.java

@@ -10 +10 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.*;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
-import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
@@ -48 +51 @@
     void saveCatalog() {
         // given
         Type type = new Type("type");
+        CatalogItemDto catalogItemDto = new CatalogItemDto();
+        catalogItemDto.setName("aaacbbbbbbbaa");
+        catalogItemDto.setBibliography(Stream.of("bibl").collect(Collectors.toSet()));
+        catalogItemDto.setTypes(Stream.of("type").collect(Collectors.toSet()));
+        catalogItemDto.setAlternativeNames(Stream.of("altName").collect(Collectors.toSet()));
+        catalogItemDto.setCountries(Stream.of("aaaabbaa").collect(Collectors.toSet()));
+        catalogItemDto.setWrittenForms(Stream.of("written").collect(Collectors.toSet()));
+        catalogItemDto.setCertainty(0);
+        catalogItemDto.setLatitude(0.1);
+        catalogItemDto.setLongitude(0.2);
+
+        CatalogItemDto catalogItemDto2 = new CatalogItemDto();
+        catalogItemDto2.setName("name");
+        catalogItemDto2.setBibliography(Stream.of("bibl").collect(Collectors.toSet()));