Revize b30f120b

Fixed title page tests

re #9363

backend/src/main/java/cz/zcu/kiv/backendapi/BackendApiApplication.java

@@ -8 +8 @@
 @SpringBootApplication
 public class BackendApiApplication {
 
-	// TODO replace with log4j?
-	public static final Logger LOGGER = Logger.getLogger(BackendApiApplication.class.getName());
+    // TODO replace with log4j?
+    public static final Logger LOGGER = Logger.getLogger(BackendApiApplication.class.getName());
 
-	public static void main(String[] args) {
-		SpringApplication.run(BackendApiApplication.class, args);
-		LOGGER.info("Swagger is running at: http://localhost:8080/swagger-ui.html");
-	}
+    public static void main(String[] args) {
+        SpringApplication.run(BackendApiApplication.class, args);
+        LOGGER.info("Swagger is running at: http://localhost:8080/swagger-ui.html");
+    }
 
 }

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.CatalogEntry;
+import cz.zcu.kiv.backendapi.catalog.CatalogItem;
 import lombok.*;
 
 import javax.persistence.*;
 import java.io.Serializable;
 
 /**
- * Alternative name entity representing alternative name of geographic entry
+ * Alternative name entity representing alternative name of catalog item
  */
 @Data
-@EqualsAndHashCode(exclude = "catalog")
-@ToString(exclude = "catalog")
+@EqualsAndHashCode(exclude = "catalogItem")
+@ToString(exclude = "catalogItem")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity
@@ -28 +28 @@
      * Catalog entity
      */
     @ManyToOne
-    @JoinColumn(name = "catalog_id")
+    @JoinColumn(name = "catalog_item_id")
     @Id
-    private CatalogEntry catalog;
+    private CatalogItem catalogItem;
 }

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.CatalogEntry;
+import cz.zcu.kiv.backendapi.catalog.CatalogItem;
 import lombok.*;
 
 import javax.persistence.*;
@@ -10 +10 @@
  * Bibliography entity representing bibliography
  */
 @Data
-@EqualsAndHashCode(exclude = "catalog")
-@ToString(exclude = "catalog")
+@EqualsAndHashCode(exclude = "catalogItem")
+@ToString(exclude = "catalogItem")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity
@@ -25 +25 @@
     private String source;
 
     @ManyToOne
-    @JoinColumn(name = "catalog_id")
-    private CatalogEntry catalog;
+    @JoinColumn(name = "catalog_item_id")
+    private CatalogItem catalogItem;
 }

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

@@ -13 +13 @@
  */
 @RestController
 @RequiredArgsConstructor
-@RequestMapping("/catalog")
+@RequestMapping("")
 public class CatalogController {
 
     /**
      * Catalog service
      */
-    private final ICatalogEntryService catalogService;
+    private final ICatalogItemService catalogService;
 
     /**
-     * Saves new catalog entry
+     * Saves new catalog item
      *
-     * @param catalogEntryDto catalog entry DTO
+     * @param catalogItemDto catalog item DTO
      */
-    @PostMapping("")
-    public void addCatalogEntry(@RequestBody CatalogEntryDto catalogEntryDto) {
-        catalogService.saveCatalogEntry(catalogEntryDto);
+    @PostMapping("/catalog-item")
+    public void addCatalogItem(@RequestBody CatalogItemDto catalogItemDto) {
+        catalogService.saveCatalogItem(catalogItemDto);
     }
 
     /**
-     * Returns catalog entries satisfying given filter
+     * Returns catalog items satisfying given filter
      *
      * @param name    name - optional
      * @param country country - optional
      * @param type    type - optional
-     * @return list of catalog entries satisfying given filter
+     * @return list of catalog items satisfying given filter
      */
-    @GetMapping("")
-    public ResponseEntity<List<CatalogEntryDto>> getCatalog(@RequestParam(defaultValue = "") String name, @RequestParam(defaultValue = "") String country, @RequestParam(defaultValue = "") String type) {
+    @GetMapping("/catalog")
+    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);
     }
 
     /**
-     * Updates catalog entry with given ID
+     * Updates catalog item with given ID
      *
-     * @param id              ID
-     * @param catalogEntryDto catalog DTO
+     * @param id             ID
+     * @param catalogItemDto catalog item DTO
      */
-    @PutMapping("/{id}")
-    public void updateCatalogEntry(@PathVariable UUID id, @RequestBody CatalogEntryDto catalogEntryDto) {
-        catalogService.updateCatalogEntry(id, catalogEntryDto);
+    @PutMapping("/catalog-item/{id}")
+    public void updateCatalogItem(@PathVariable UUID id, @RequestBody CatalogItemDto catalogItemDto) {
+        catalogService.updateCatalogItem(id, catalogItemDto);
     }
 
     /**
-     * Deletes catalog entry with given ID
+     * Deletes catalog item with given ID
      *
      * @param id ID
      */
-    @DeleteMapping("/{id}")
-    public void deleteCatalogEntry(@PathVariable UUID id) {
-        catalogService.deleteCatalogEntry(id);
+    @DeleteMapping("/catalog-item/{id}")
+    public void deleteCatalogItem(@PathVariable UUID id) {
+        catalogService.deleteCatalogItem(id);
     }
 }

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.catalog;
-
-import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
-import cz.zcu.kiv.backendapi.bibliography.Bibliography;
-import cz.zcu.kiv.backendapi.country.Country;
-import cz.zcu.kiv.backendapi.type.Type;
-import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
-import lombok.*;
-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;
-
-/**
- * Catalog entity representing catalog entry
- */
-@Data
-@NoArgsConstructor
-@Entity
-@Table(name = "catalog")
-public class CatalogEntry {
-    private static final String INTEGER_PATTERN = "\\d+";
-    private static final String DOUBLE_PATTERN = "(\\d+[.]\\d+)|(\\d+)";
-    private static final String EMPTY_ENTRY = "–";
-    /**
-     * Catalog entry id
-     */
-    @Id
-    @GeneratedValue
-    private UUID id;
-
-    /**
-     * Name of geographic entry
-     */
-    private String name;
-
-    /**
-     * Certainty
-     */
-    private int certainty;
-
-    /**
-     * Longitude
-     */
-    private double longitude;
-
-    /**
-     * Latitude
-     */
-    private double latitude;
-
-    /**
-     * Bibliography
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<Bibliography> bibliography = Collections.emptySet();
-
-    /**
-     * Countries
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<Country> countries = Collections.emptySet();
-
-    /**
-     * Written forms
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<WrittenForm> writtenForms = Collections.emptySet();
-
-    /**
-     * Alternative names
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<AlternativeName> alternativeNames = Collections.emptySet();
-
-    /**
-     * Set of user roles - many-to-many relationship
-     */
-    @ManyToMany(fetch = FetchType.EAGER)
-    @JoinTable(
-            name = "catalog_type",
-            joinColumns = {
-                    @JoinColumn(name = "catalog_id", referencedColumnName = "id")
-            },
-            inverseJoinColumns = {
-                    @JoinColumn(name = "type", referencedColumnName = "type")
-            }
-    )
-    private Set<Type> types = Collections.emptySet();
-
-    public CatalogEntry(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());
-    }
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.catalog;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Collections;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Class representing catalog entry DTO
- */
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class CatalogEntryDto {
-    /**
-     * Id
-     */
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    private UUID id;
-
-    /**
-     * Name of geographic entry
-     */
-    private String name;
-
-    /**
-     * Certainty
-     */
-    private int certainty;
-
-    /**
-     * Longitude
-     */
-    private double longitude;
-
-    /**
-     * Latitude
-     */
-    private double latitude;
-
-    /**
-     * Bibliography
-     */
-    private Set<String> bibliography = Collections.emptySet();
-
-    /**
-     * Countries
-     */
-    private Set<String> countries = Collections.emptySet();
-
-    /**
-     * Written forms
-     */
-    private Set<String> writtenForms = Collections.emptySet();
-
-    /**
-     * Alternative names
-     */
-    private Set<String> alternativeNames = Collections.emptySet();
-
-    /**
-     * Types
-     */
-    private Set<String> types = Collections.emptySet();
-
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.catalog;
-
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.stereotype.Repository;
-
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Catalog repository
- */
-@Repository
-public interface CatalogEntryRepository extends JpaRepository<CatalogEntry, UUID> {
-
-    /**
-     * Returns all catalog entries containing specific values
-     *
-     * @param name    name - optional
-     * @param country country - optional
-     * @param type    type - optional
-     * @return set of catalog entries satisfying filter conditions
-     */
-    @Query("SELECT DISTINCT e FROM CatalogEntry e LEFT JOIN AlternativeName a ON e = a.catalog " +
-            "LEFT JOIN Country c ON e = c.catalog " +
-            "INNER 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<CatalogEntry> filterCatalog(String name, String country, String type);
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.catalog;
-
-import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
-import cz.zcu.kiv.backendapi.bibliography.Bibliography;
-import cz.zcu.kiv.backendapi.country.Country;
-import cz.zcu.kiv.backendapi.exception.ApiRequestException;
-import cz.zcu.kiv.backendapi.type.ITypeService;
-import cz.zcu.kiv.backendapi.type.Type;
-import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
-import lombok.RequiredArgsConstructor;
-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.stream.Collectors;
-
-/**
- * Catalog entry service implementation
- */
-@Service
-@Transactional
-@RequiredArgsConstructor
-@Slf4j
-public class CatalogEntryServiceImpl implements ICatalogEntryService {
-    /**
-     * Regex for one arbitrary character in string
-     */
-    private static final String WILDCARD_CHARACTER_REGEX = "\\?";
-
-    /**
-     * Regex for one arbitrary character in string used in SQL language
-     */
-    private static final String WILDCARD_CHARACTER_REGEX_SQL = "_";
-
-    /**
-     * Regex for any number of arbitrary characters in string
-     */
-    private static final String WILDCARD_CHARACTERS_REGEX = "\\*";
-
-    /**
-     * Regex for any number of arbitrary characters in string used in SQL language
-     */
-    private static final String WILDCARD_CHARACTERS_REGEX_SQL = "%";
-
-    /**
-     * Message for exception when catalog entry is not found by id
-     */
-    private static final String CATALOG_ENTRY_NOT_FOUND = "Catalog entry not found";
-
-    /**
-     * Catalog repository
-     */
-    private final CatalogEntryRepository catalogEntryRepository;
-
-    /**
-     * Type service
-     */
-    private final ITypeService typeService;
-
-    @Override
-    public void saveCatalog(List<CatalogEntry> catalogEntities) {
-        log.info("Saving catalog");
-        catalogEntities.forEach(this::saveCatalogEntity);
-    }
-
-    @Override
-    public void saveCatalogEntry(CatalogEntryDto catalogEntryDto) {
-        log.info("Saving catalog entry");
-        CatalogEntry catalogEntry = new CatalogEntry();
-        convertDtoToEntity(catalogEntryDto, catalogEntry);
-        saveCatalogEntity(catalogEntry);
-    }
-
-    @Override
-    public void updateCatalogEntry(UUID id, CatalogEntryDto catalogEntryDto) {
-        CatalogEntry catalogEntry = catalogEntryRepository.findById(id).orElseThrow(() -> {
-            log.error(CATALOG_ENTRY_NOT_FOUND);
-            throw new ApiRequestException(CATALOG_ENTRY_NOT_FOUND, HttpStatus.NOT_FOUND);
-        });
-        convertDtoToEntity(catalogEntryDto, catalogEntry);
-        saveCatalogEntity(catalogEntry);
-        log.info("Catalog entry updated");
-    }
-
-    @Override
-    public void deleteCatalogEntry(UUID id) {
-        if (!catalogEntryRepository.existsById(id)) {
-            log.error(CATALOG_ENTRY_NOT_FOUND);
-            throw new ApiRequestException(CATALOG_ENTRY_NOT_FOUND, HttpStatus.NOT_FOUND);
-        }
-        catalogEntryRepository.deleteById(id);
-        log.info("Catalog entry deleted");
-    }
-
-    @Override
-    public List<CatalogEntryDto> getCatalog(String name, String country, String type) {
-        log.info("Retrieving catalog");
-        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<CatalogEntry> entities = catalogEntryRepository.filterCatalog(name, country, type);
-        return entities.stream().map(this::convertEntityToDto).collect(Collectors.toList());
-    }
-
-    /**
-     * Saves catalog entity to database
-     *
-     * @param catalogEntry catalog entity
-     */
-    private void saveCatalogEntity(CatalogEntry catalogEntry) {
-        for (Type type : catalogEntry.getTypes()) {
-            if (typeService.getTypeByName(type.getType()).isEmpty()) {
-                typeService.saveType(type);
-            }
-        }
-        catalogEntryRepository.save(catalogEntry);
-    }
-
-    /**
-     * Converts catalog DTO to catalog entity
-     *
-     * @param catalogEntryDto catalog DTO
-     * @param catalogEntry    catalog entity
-     */
-    private void convertDtoToEntity(CatalogEntryDto catalogEntryDto, CatalogEntry catalogEntry) {
-        catalogEntry.setName(catalogEntryDto.getName());
-        catalogEntry.setCertainty(catalogEntryDto.getCertainty());
-        catalogEntry.setLatitude(catalogEntryDto.getLatitude());
-        catalogEntry.setLongitude(catalogEntryDto.getLongitude());
-        catalogEntry.setBibliography(catalogEntryDto.getBibliography()
-                .stream().map(s -> new Bibliography(s, catalogEntry)).collect(Collectors.toSet()));
-        catalogEntry.setTypes(catalogEntryDto.getTypes()
-                .stream().map(Type::new).collect(Collectors.toSet()));
-        catalogEntry.setCountries(catalogEntryDto.getCountries()
-                .stream().map(s -> new Country(s, catalogEntry)).collect(Collectors.toSet()));
-        catalogEntry.setAlternativeNames(catalogEntryDto.getAlternativeNames()
-                .stream().map(s -> new AlternativeName(s, catalogEntry)).collect(Collectors.toSet()));
-        catalogEntry.setWrittenForms(catalogEntryDto.getWrittenForms()
-                .stream().map(s -> new WrittenForm(s, catalogEntry)).collect(Collectors.toSet()));
-    }
-
-    /**
-     * Converts catalog entity to catalog DTO
-     *
-     * @param entity catalog entity
-     * @return catalog DTO
-     */
-    private CatalogEntryDto convertEntityToDto(CatalogEntry entity) {
-        CatalogEntryDto catalogEntryDto = new CatalogEntryDto();
-        catalogEntryDto.setId(entity.getId());
-        catalogEntryDto.setName(entity.getName());
-        catalogEntryDto.setLatitude(entity.getLatitude());
-        catalogEntryDto.setLongitude(entity.getLongitude());
-        catalogEntryDto.setCertainty(entity.getCertainty());
-        catalogEntryDto.setBibliography(entity.getBibliography()
-                .stream().map(Bibliography::getSource).collect(Collectors.toSet()));
-        catalogEntryDto.setTypes(entity.getTypes()
-                .stream().map(Type::getType).collect(Collectors.toSet()));
-        catalogEntryDto.setCountries(entity.getCountries()
-                .stream().map(Country::getName).collect(Collectors.toSet()));
-        catalogEntryDto.setAlternativeNames(entity.getAlternativeNames()
-                .stream().map(AlternativeName::getName).collect(Collectors.toSet()));
-        catalogEntryDto.setWrittenForms(entity.getWrittenForms()
-                .stream().map(WrittenForm::getForm).collect(Collectors.toSet()));
-        return catalogEntryDto;
-    }
-
-}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
+import cz.zcu.kiv.backendapi.bibliography.Bibliography;
+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.NoArgsConstructor;
+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;
+
+/**
+ * Catalog entity representing catalog item
+ */
+@Data
+@NoArgsConstructor
+@Entity
+@Table(name = "catalog_item")
+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
+     */
+    @Id
+    @GeneratedValue
+    private UUID id;
+
+    /**
+     * Name of geographic item
+     */
+    private String name;
+
+    /**
+     * Certainty
+     */
+    private int certainty;
+
+    /**
+     * Longitude
+     */
+    private double longitude;
+
+    /**
+     * Latitude
+     */
+    private double latitude;
+
+    /**
+     * Bibliography
+     */
+    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<Bibliography> bibliography = Collections.emptySet();
+
+    /**
+     * Countries
+     */
+    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<Country> countries = Collections.emptySet();
+
+    /**
+     * Written forms
+     */
+    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<WrittenForm> writtenForms = Collections.emptySet();
+
+    /**
+     * Alternative names
+     */
+    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<AlternativeName> alternativeNames = Collections.emptySet();
+
+    /**
+     * Set of user roles - many-to-many relationship
+     */
+    @ManyToMany(fetch = FetchType.EAGER)
+    @JoinTable(
+            name = "catalog_item_type",
+            joinColumns = {
+                    @JoinColumn(name = "catalog_item_id", referencedColumnName = "id")
+            },
+            inverseJoinColumns = {
+                    @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());
+    }
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Class representing catalog item DTO
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class CatalogItemDto {
+    /**
+     * Id
+     */
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    private UUID id;
+
+    /**
+     * Name of catalog item
+     */
+    private String name;
+
+    /**
+     * Certainty
+     */
+    private int certainty;
+
+    /**
+     * Longitude
+     */
+    private double longitude;
+
+    /**
+     * Latitude
+     */
+    private double latitude;
+
+    /**
+     * Bibliography
+     */
+    private Set<String> bibliography = Collections.emptySet();
+
+    /**
+     * Countries
+     */
+    private Set<String> countries = Collections.emptySet();
+
+    /**
+     * Written forms
+     */
+    private Set<String> writtenForms = Collections.emptySet();
+
+    /**
+     * Alternative names
+     */
+    private Set<String> alternativeNames = Collections.emptySet();
+
+    /**
+     * Types
+     */
+    private Set<String> types = Collections.emptySet();
+
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Catalog repository
+ */
+@Repository
+public interface CatalogItemRepository extends JpaRepository<CatalogItem, UUID> {
+
+    /**
+     * Returns all catalog items containing specific values
+     *
+     * @param name    name - optional
+     * @param country country - optional
+     * @param type    type - optional
+     * @return set of catalog items satisfying filter conditions
+     */
+    @Query("SELECT DISTINCT e FROM CatalogItem e LEFT JOIN AlternativeName a ON e = a.catalogItem " +
+            "LEFT JOIN Country c ON e = c.catalogItem " +
+            "INNER 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);
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
+import cz.zcu.kiv.backendapi.bibliography.Bibliography;
+import cz.zcu.kiv.backendapi.country.Country;
+import cz.zcu.kiv.backendapi.exception.ApiRequestException;
+import cz.zcu.kiv.backendapi.type.ITypeService;
+import cz.zcu.kiv.backendapi.type.Type;
+import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
+import lombok.RequiredArgsConstructor;
+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.stream.Collectors;
+
+/**
+ * Catalog item service implementation
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+@Slf4j
+public class CatalogItemServiceImpl implements ICatalogItemService {
+    /**
+     * Regex for one arbitrary character in string
+     */
+    private static final String WILDCARD_CHARACTER_REGEX = "\\?";
+
+    /**
+     * Regex for one arbitrary character in string used in SQL language
+     */
+    private static final String WILDCARD_CHARACTER_REGEX_SQL = "_";
+
+    /**
+     * Regex for any number of arbitrary characters in string
+     */
+    private static final String WILDCARD_CHARACTERS_REGEX = "\\*";
+
+    /**
+     * Regex for any number of arbitrary characters in string used in SQL language
+     */
+    private static final String WILDCARD_CHARACTERS_REGEX_SQL = "%";
+
+    /**
+     * Message for exception when catalog item is not found by id
+     */
+    private static final String CATALOG_ITEM_NOT_FOUND = "Catalog item not found";
+
+    /**
+     * Catalog repository
+     */
+    private final CatalogItemRepository catalogItemRepository;
+
+    /**
+     * Type service
+     */
+    private final ITypeService typeService;
+
+    @Override
+    public void saveCatalog(List<CatalogItem> catalogItems) {
+        log.info("Saving catalog");
+        catalogItems.forEach(this::saveCatalogEntity);
+    }
+
+    @Override
+    public void saveCatalogItem(CatalogItemDto catalogItemDto) {
+        log.info("Saving catalog item");
+        CatalogItem catalogItem = new CatalogItem();
+        convertDtoToEntity(catalogItemDto, catalogItem);
+        saveCatalogEntity(catalogItem);
+    }
+
+    @Override
+    public void updateCatalogItem(UUID id, CatalogItemDto catalogItemDto) {
+        CatalogItem catalogItem = catalogItemRepository.findById(id).orElseThrow(() -> {
+            log.error(CATALOG_ITEM_NOT_FOUND);
+            throw new ApiRequestException(CATALOG_ITEM_NOT_FOUND, HttpStatus.NOT_FOUND);
+        });
+        convertDtoToEntity(catalogItemDto, catalogItem);
+        saveCatalogEntity(catalogItem);
+        log.info("Catalog item updated");
+    }
+
+    @Override
+    public void deleteCatalogItem(UUID id) {
+        if (!catalogItemRepository.existsById(id)) {
+            log.error(CATALOG_ITEM_NOT_FOUND);
+            throw new ApiRequestException(CATALOG_ITEM_NOT_FOUND, HttpStatus.NOT_FOUND);
+        }
+        catalogItemRepository.deleteById(id);
+        log.info("Catalog item deleted");
+    }
+
+    @Override
+    public List<CatalogItemDto> getCatalog(String name, String country, String type) {
+        log.info("Retrieving catalog");
+        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());
+    }
+
+    /**
+     * Saves catalog entity to database
+     *
+     * @param catalogItem catalog entity
+     */
+    private void saveCatalogEntity(CatalogItem catalogItem) {
+        for (Type type : catalogItem.getTypes()) {
+            if (typeService.getTypeByName(type.getType()).isEmpty()) {
+                typeService.saveType(type);
+            }
+        }
+        catalogItemRepository.save(catalogItem);
+    }
+
+    /**
+     * Converts catalog DTO to catalog entity
+     *
+     * @param catalogItemDto catalog DTO
+     * @param catalogItem    catalog entity
+     */
+    private void convertDtoToEntity(CatalogItemDto catalogItemDto, CatalogItem catalogItem) {
+        catalogItem.setName(catalogItemDto.getName());
+        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()));
+    }
+
+    /**
+     * Converts catalog entity to catalog DTO
+     *
+     * @param entity catalog entity
+     * @return catalog DTO
+     */
+    private CatalogItemDto convertEntityToDto(CatalogItem entity) {
+        CatalogItemDto catalogItemDto = new CatalogItemDto();
+        catalogItemDto.setId(entity.getId());
+        catalogItemDto.setName(entity.getName());
+        catalogItemDto.setLatitude(entity.getLatitude());
+        catalogItemDto.setLongitude(entity.getLongitude());
+        catalogItemDto.setCertainty(entity.getCertainty());
+        catalogItemDto.setBibliography(entity.getBibliography()
+                .stream().map(Bibliography::getSource).collect(Collectors.toSet()));
+        catalogItemDto.setTypes(entity.getTypes()
+                .stream().map(Type::getType).collect(Collectors.toSet()));
+        catalogItemDto.setCountries(entity.getCountries()
+                .stream().map(Country::getName).collect(Collectors.toSet()));
+        catalogItemDto.setAlternativeNames(entity.getAlternativeNames()
+                .stream().map(AlternativeName::getName).collect(Collectors.toSet()));
+        catalogItemDto.setWrittenForms(entity.getWrittenForms()
+                .stream().map(WrittenForm::getForm).collect(Collectors.toSet()));
+        return catalogItemDto;
+    }
+
+}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.catalog;
-
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Catalog service interface
- */
-public interface ICatalogEntryService {
-    /**
-     * Saves list of catalog entries
-     *
-     * @param catalogEntities catalog entris
-     */
-    void saveCatalog(List<CatalogEntry> catalogEntities);
-
-    /**
-     * Saves one catalog entry
-     *
-     * @param catalogEntryDto catalog DTO
-     */
-    void saveCatalogEntry(CatalogEntryDto catalogEntryDto);
-
-    /**
-     * Updates catalog entry with given ID
-     *
-     * @param id         ID
-     * @param catalogEntryDto catalog DTO
-     */
-    void updateCatalogEntry(UUID id, CatalogEntryDto catalogEntryDto);
-
-    /**
-     * Deletes catalog entry with given ID
-     *
-     * @param id ID
-     */
-    void deleteCatalogEntry(UUID id);
-
-    /**
-     * Returns catalog entries satisfying given filter
-     *
-     * @param name    name - optional
-     * @param country country - optional
-     * @param type    type - optional
-     * @return list of catalog entries satisfying given filter
-     */
-    List<CatalogEntryDto> getCatalog(String name, String country, String type);
-
-}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Catalog service interface
+ */
+public interface ICatalogItemService {
+    /**
+     * Saves list of catalog items
+     *
+     * @param catalogItems catalog items
+     */
+    void saveCatalog(List<CatalogItem> catalogItems);
+
+    /**
+     * Saves one catalog item
+     *
+     * @param catalogItemDto catalog item DTO
+     */
+    void saveCatalogItem(CatalogItemDto catalogItemDto);
+
+    /**
+     * Updates catalog item with given ID
+     *
+     * @param id             ID
+     * @param catalogItemDto catalog item DTO
+     */
+    void updateCatalogItem(UUID id, CatalogItemDto catalogItemDto);
+
+    /**
+     * Deletes catalog item with given ID
+     *
+     * @param id ID
+     */
+    void deleteCatalogItem(UUID id);
+
+    /**
+     * Returns catalog items satisfying given filter
+     *
+     * @param name    name - optional
+     * @param country country - optional
+     * @param type    type - optional
+     * @return list of catalog items satisfying given filter
+     */
+    List<CatalogItemDto> getCatalog(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.CatalogEntry;
-import cz.zcu.kiv.backendapi.catalog.CatalogEntryRepository;
-import cz.zcu.kiv.backendapi.catalog.ICatalogEntryService;
+import cz.zcu.kiv.backendapi.catalog.CatalogItem;
+import cz.zcu.kiv.backendapi.catalog.CatalogItemRepository;
+import cz.zcu.kiv.backendapi.catalog.ICatalogItemService;
+import cz.zcu.kiv.backendapi.titlepage.ITitlePageService;
+import cz.zcu.kiv.backendapi.titlepage.TitlePage;
 import cz.zcu.kiv.backendapi.type.ITypeService;
 import cz.zcu.kiv.backendapi.type.Type;
 import cz.zcu.kiv.backendapi.user.UserEntity;
@@ -29 +31 @@
 @RequiredArgsConstructor
 public class DataInitiator implements ApplicationListener<ContextRefreshedEvent> {
 
-    private final ICatalogEntryService catalogService;
+    private final ICatalogItemService catalogService;
 
     private final ITypeService typeService;
 
-    private final CatalogEntryRepository catalogEntryRepository;
+    private final CatalogItemRepository catalogItemRepository;
 
     private final UserRepository userRepository;
 
+    private final ITitlePageService titlePageService;
+
     private final BCryptPasswordEncoder encoder;
 
     @Override
@@ -46 +50 @@
         for (Type type : types) {
             typeService.saveType(type);
         }
-        List<CatalogEntry> catalog = loadCatalog();
+        List<CatalogItem> catalog = loadCatalog();
         catalogService.saveCatalog(catalog);
 
+        titlePageService.updateTitlePage(new TitlePage(1L, "", ""));
+
         UserEntity user1 = new UserEntity("admin", "admin", encoder.encode("password"), (byte) 7, true);
         userRepository.save(user1);
 
@@ -57 +63 @@
 
     }
 
-    private List<CatalogEntry> loadCatalog() {
-        List<CatalogEntry> catalogEntities = new ArrayList<>();
+    private List<CatalogItem> loadCatalog() {
+        List<CatalogItem> catalogEntities = new ArrayList<>();
         File csvData = new File("AssyrianProject-AllNoDupl-22-03-28.csv");
         CSVParser parser;
         try {
@@ -67 +73 @@
                     .setSkipHeaderRecord(true)
                     .build());
             for (CSVRecord csvRecord : parser) {
-                catalogEntities.add(new CatalogEntry(csvRecord.toList()));
+                catalogEntities.add(new CatalogItem(csvRecord.toList()));
             }
         } catch (IOException e) {
             e.printStackTrace();

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.CatalogEntry;
+import cz.zcu.kiv.backendapi.catalog.CatalogItem;
 import lombok.*;
 
 import javax.persistence.*;
 import java.io.Serializable;
 
 /**
- * Country entity representing country of geographic entry
+ * Country entity representing country of catalog item
  */
 @Data
-@EqualsAndHashCode(exclude = "catalog")
-@ToString(exclude = "catalog")
+@EqualsAndHashCode(exclude = "catalogItem")
+@ToString(exclude = "catalogItem")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity
@@ -25 +25 @@
     private String name;
 
     @ManyToOne
-    @JoinColumn(name = "catalog_id")
+    @JoinColumn(name = "catalog_item_id")
     @Id
-    private CatalogEntry catalog;
+    private CatalogItem catalogItem;
 }

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

@@ -3 +3 @@
 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.permission.Permission;
 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;

backend/src/main/java/cz/zcu/kiv/backendapi/security/jwt/JwtUtils.java

@@ -59 +59 @@
      * Claim authorities name
      */
     private String claimAuthoritiesName;
-    
+
 
     /**
      * Returns algorithm for JWT

backend/src/main/java/cz/zcu/kiv/backendapi/titlepage/ITitlePageService.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.titlepage;
 
-import java.util.List;
-
 /**
  * Title page service interface
  */
 public interface ITitlePageService {
     /**
-     * Returns all title pages
+     * Returns title page
      *
-     * @return list of title pages
+     * @return title page
      */
-    List<TitlePage> getTitlePages();
+    TitlePage getTitlePage();
 
     /**
      * Adds or updates title page with given ID
      *
-     * @param id        ID
      * @param titlePage title page
      */
-    void addOrUpdateTitlePage(Long id, TitlePage titlePage);
+    void updateTitlePage(TitlePage titlePage);
 
 }

backend/src/main/java/cz/zcu/kiv/backendapi/titlepage/TitlePage.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.titlepage;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
-import javax.persistence.*;
-import java.util.UUID;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
 
 /**
  * Class representing title page
@@ -21 +23 @@
      * ID
      */
     @Id
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonIgnore
     private Long id;
 
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/titlepage/TitlePageController.java

@@ -5 +5 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-
 /**
  * Controller for title page
  */
@@ -20 +18 @@
     private final ITitlePageService titlePageService;
 
     /**
-     * Returns list of all title pages
+     * Returns title page
      *
-     * @return list of all title pages
+     * @return title page
      */
     @GetMapping("")
-    public ResponseEntity<List<TitlePage>> getAllTitlePages() {
-        return new ResponseEntity<>(titlePageService.getTitlePages(), HttpStatus.OK);
+    public ResponseEntity<TitlePage> getTitlePage() {
+        return new ResponseEntity<>(titlePageService.getTitlePage(), HttpStatus.OK);
     }
 
     /**
-     * Adds or updates title page
+     * Updates title page
      *
-     * @param id ID of page to be created/updated
      * @param titlePage title page
      */
-    @PutMapping("/{id}")
-    public void updateTitlePage(@PathVariable Long id, @RequestBody TitlePage titlePage) {
-        titlePageService.addOrUpdateTitlePage(id, titlePage);
+    @PostMapping("")
+    public void updateTitlePage(@RequestBody TitlePage titlePage) {
+        titlePageService.updateTitlePage(titlePage);
     }
 
 }

backend/src/main/java/cz/zcu/kiv/backendapi/titlepage/TitlePageServiceImplementation.java

@@ -5 +5 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
+import java.util.Optional;
 
 /**
  * Title page service implementation
@@ -15 +15 @@
 @RequiredArgsConstructor
 @Slf4j
 public class TitlePageServiceImplementation implements ITitlePageService {
+    /**
+     * ID of the title page
+     */
+    private static final long TITLE_PAGE_ID = 1;
+
     /**
      * Title page repository
      */
     private final TitlePageRepository titlePageRepository;
 
     @Override
-    public List<TitlePage> getTitlePages() {
-        return titlePageRepository.findAll();
+    public TitlePage getTitlePage() {
+        Optional<TitlePage> optionalTitlePage = titlePageRepository.findById(TITLE_PAGE_ID);
+        if (optionalTitlePage.isEmpty()) {
+            TitlePage titlePage = new TitlePage(TITLE_PAGE_ID, "", "");
+            return titlePageRepository.save(titlePage);
+        }
+        return optionalTitlePage.get();
     }
 
     @Override
-    public void addOrUpdateTitlePage(Long id, TitlePage titlePage) {
-        titlePage.setId(id);
+    public void updateTitlePage(TitlePage titlePage) {
+        titlePage.setId(TITLE_PAGE_ID);
         titlePageRepository.save(titlePage);
     }
 }

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

@@ -9 +9 @@
 import javax.persistence.Table;
 
 /**
- * Type entity representing type of geographic entry
+ * Type entity representing type of catalog item
  */
 @Data
 @NoArgsConstructor

backend/src/main/java/cz/zcu/kiv/backendapi/user/IUserService.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.user;
 
-import cz.zcu.kiv.backendapi.user.password.PasswordDto;
 import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
 
 import java.util.List;