Revize e111342b

Added JWT and permissions, changed project structure
- filters when authenticating - sends JWT
- filters per request - controls JWT
- added permission to user (READ, WRITE, DELETE)
- created package-by-feature from package-by-layer
re #9204

backend/pom.xml

@@ -66 +66 @@
             <artifactId>commons-csv</artifactId>
             <version>1.9.0</version>
         </dependency>
+
+        <dependency>
+            <groupId>com.auth0</groupId>
+            <artifactId>java-jwt</artifactId>
+            <version>3.19.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>31.1-jre</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <version>2.4.2</version>
+            <optional>true</optional>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.alternativename;
+
+import cz.zcu.kiv.backendapi.catalog.CatalogEntity;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+/**
+ * Alternative name entity representing alternative name of geographic entry
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "alternative_names")
+@IdClass(AlternativeNameEntity.class)
+public class AlternativeNameEntity implements Serializable {
+    /**
+     * Name, serves as ID
+     */
+    @Id
+    private String name;
+
+    /**
+     * Catalog entity
+     */
+    @ManyToOne
+    @JoinColumn(name = "catalog_id")
+    @Id
+    private CatalogEntity catalog;
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.alternativename;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Alternative name repository
+ */
+@Repository
+@Transactional(readOnly = true)
+public interface AlternativeNameRepository extends JpaRepository<AlternativeNameEntity, AlternativeNameEntity> {
+}

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/BibliographyEntity.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.bibliography;
+
+import cz.zcu.kiv.backendapi.catalog.CatalogEntity;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+/**
+ * Bibliography entity representing bibliography
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "bibliography")
+@IdClass(BibliographyEntity.class)
+public class BibliographyEntity implements Serializable {
+    /**
+     * Source, serves as ID
+     */
+    @Id
+    private String source;
+
+    @ManyToOne
+    @JoinColumn(name = "catalog_id")
+    private CatalogEntity catalog;
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.bibliography;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Bibliography repository
+ */
+@Repository
+@Transactional(readOnly = true)
+public interface BibliographyRepository extends JpaRepository<BibliographyEntity, BibliographyEntity> {
+}

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/CatalogEntity.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import cz.zcu.kiv.backendapi.alternativename.AlternativeNameEntity;
+import cz.zcu.kiv.backendapi.bibliography.BibliographyEntity;
+import cz.zcu.kiv.backendapi.country.CountryEntity;
+import cz.zcu.kiv.backendapi.type.TypeEntity;
+import cz.zcu.kiv.backendapi.writtenform.WrittenFormEntity;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+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
+ */
+//@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name = "catalog")
+public class CatalogEntity {
+    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<BibliographyEntity> bibliography;
+
+    /**
+     * Countries
+     */
+    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<CountryEntity> countries;
+
+    /**
+     * Written forms
+     */
+    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<WrittenFormEntity> writtenForms;
+
+    /**
+     * Alternative name
+     */
+    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
+    @LazyCollection(LazyCollectionOption.FALSE)
+    private Set<AlternativeNameEntity> alternativeNames;
+
+    /**
+     * 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<TypeEntity> types = Collections.emptySet();
+
+    public CatalogEntity(final List<String> csvFields) {
+
+        this.name = csvFields.get(1);
+        List<String> stringList = processListField(csvFields.get(2));
+        this.alternativeNames = new HashSet<>(stringList.size());
+        for (String s : stringList) {
+            this.alternativeNames.add(new AlternativeNameEntity(s, this));
+        }
+        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.size());
+        for (String s : stringList) {
+            this.writtenForms.add(new WrittenFormEntity(s, this));
+        }
+        stringList = processListField(csvFields.get(7));
+        this.types = new HashSet<>(stringList.size());
+        for (String s : stringList) {
+            this.types.add(new TypeEntity(s));
+        }
+        stringList = processListField(csvFields.get(8));
+        this.countries = new HashSet<>(stringList.size());
+        for (String s : stringList) {
+            this.countries.add(new CountryEntity(s, this));
+        }
+        stringList = processListField(csvFields.get(10));
+        this.bibliography = new HashSet<>(stringList.size());
+        for (String s : stringList) {
+            this.bibliography.add(new BibliographyEntity(s, this));
+        }
+    }
+
+    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/CatalogRepository.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 org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Catalog repository
+ */
+@Repository
+@Transactional(readOnly = true)
+public interface CatalogRepository extends JpaRepository<CatalogEntity, UUID> {
+
+    /**
+     * Selects all catalog entries with given name or where given name appears in alternative names
+     * @param name name
+     * @return list of catalog entries with given name / alternative name
+     */
+    @Query("SELECT DISTINCT c FROM CatalogEntity c LEFT JOIN AlternativeNameEntity a ON c = a.catalog WHERE (?1 = c.name OR ?1 = a.name)")
+    List<CatalogEntity> getCatalogEntitiesByName(String name);
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import cz.zcu.kiv.backendapi.type.TypeEntity;
+import cz.zcu.kiv.backendapi.type.ITypeService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * Catalog service implementation
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class CatalogServiceImpl implements ICatalogService {
+    /**
+     * Catalog repository
+     */
+    private final CatalogRepository catalogRepository;
+
+    private final ITypeService typeService;
+
+    @Override
+    public void saveCatalog(List<CatalogEntity> catalogEntities) {
+        for (CatalogEntity catalogEntity : catalogEntities) {
+            for (TypeEntity type: catalogEntity.getTypes()                 ) {
+
+                if (typeService.getTypeByName(type.getType()).isEmpty()){
+                    typeService.saveType(type);
+                }
+            }
+        }
+        catalogRepository.saveAll(catalogEntities);
+    }
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import java.util.List;
+
+/**
+ * Catalog service interface
+ */
+public interface ICatalogService {
+    void saveCatalog(List<CatalogEntity> catalogEntities);
+}

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

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.config;
 
-import cz.zcu.kiv.backendapi.model.CatalogEntity;
-import cz.zcu.kiv.backendapi.service.catalog.ICatalogService;
+import cz.zcu.kiv.backendapi.catalog.CatalogEntity;
+import cz.zcu.kiv.backendapi.type.TypeEntity;
+import cz.zcu.kiv.backendapi.catalog.CatalogRepository;
+import cz.zcu.kiv.backendapi.catalog.ICatalogService;
+import cz.zcu.kiv.backendapi.type.ITypeService;
+import cz.zcu.kiv.backendapi.user.UserEntity;
+import cz.zcu.kiv.backendapi.user.UserRepository;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.CSVRecord;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
@@ -24 +31 @@
 
     private final ICatalogService catalogService;
 
+    private final ITypeService typeService;
+
+    private final CatalogRepository catalogRepository;
+
+    private final UserRepository userRepository;
+
+    private final BCryptPasswordEncoder encoder;
+
     @Override
     @Transactional
     public void onApplicationEvent(ContextRefreshedEvent event) {
+        List<TypeEntity> types = loadTypes();
+        typeService.saveTypes(types);
         List<CatalogEntity> catalog = loadCatalog();
         catalogService.saveCatalog(catalog);
 
+        UserEntity user1 = new UserEntity("admin", "admin", encoder.encode("password"), (byte) 7, true);
+        userRepository.save(user1);
+
+        UserEntity user2 = new UserEntity("normal", "normal", encoder.encode("password"), (byte) 1, false);
+        userRepository.save(user2);
+
     }
 
     private List<CatalogEntity> loadCatalog() {
@@ -50 +73 @@
         return catalogEntities;
 
     }
+
+    private List<TypeEntity> loadTypes() {
+        List<TypeEntity> types = new ArrayList<>();
+        CSVParser parser;
+        File csvData = new File("AssyrianProject-All.csv");
+        try {
+            parser = CSVParser.parse(csvData, Charset.defaultCharset(), CSVFormat.DEFAULT.builder().setSkipHeaderRecord(true).build());
+            for (CSVRecord csvRecord : parser) {
+                if (csvRecord.get(0).equals("10000")) {
+                    types.add(new TypeEntity(csvRecord.get(2)));
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return types;
+    }
 }

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.country;
+
+import cz.zcu.kiv.backendapi.catalog.CatalogEntity;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+/**
+ * Country entity representing country of geographic entry
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "countries")
+@IdClass(CountryEntity.class)
+public class CountryEntity implements Serializable {
+    /**
+     * Name of country, serves as ID
+     */
+    @Id
+    private String name;
+
+    @ManyToOne
+    @JoinColumn(name = "catalog_id")
+    @Id
+    private CatalogEntity catalog;
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.country;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Country repository
+ */
+@Repository
+@Transactional(readOnly = true)
+public interface CountryRepository extends JpaRepository<CountryEntity, CountryEntity> {
+}

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/exception/ApiExceptionHandler.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.exception;
+
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class ApiExceptionHandler {
+
+    @ExceptionHandler(value = {ApiRequestException.class})
+    public ResponseEntity<Object> handleApiRequestException(ApiRequestException exception) {
+        return new ResponseEntity<>(exception, exception.getHttpStatus());
+    }
+}

backend/src/main/java/cz/zcu/kiv/backendapi/exception/ApiRequestException.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.exception;
+
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+@Getter
+public class ApiRequestException extends RuntimeException {
+    private final HttpStatus httpStatus;
+
+    public ApiRequestException(String message, HttpStatus httpStatus) {
+        super(message);
+        this.httpStatus = httpStatus;
+    }
+
+    public ApiRequestException(String message, Throwable cause, HttpStatus httpStatus) {
+        super(message, cause);
+        this.httpStatus = httpStatus;
+    }
+}

backend/src/main/java/cz/zcu/kiv/backendapi/model/AlternativeNameEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.persistence.*;
-import java.io.Serializable;
-import java.util.UUID;
-
-/**
- * Alternative name entity representing alternative name of geographic entry
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "alternative_names")
-@IdClass(AlternativeNameEntity.class)
-public class AlternativeNameEntity implements Serializable {
-    /**
-     * Name, serves as ID
-     */
-    @Id
-    private String name;
-
-    /**
-     * Catalog entity
-     */
-    @ManyToOne
-    @JoinColumn(name = "catalog_id")
-    @Id
-    private CatalogEntity catalog;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/BibliographyEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.persistence.*;
-import java.io.Serializable;
-
-/**
- * Bibliography entity representing bibliography
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "bibliography")
-@IdClass(BibliographyEntity.class)
-public class BibliographyEntity implements Serializable {
-    /**
-     * Source, serves as ID
-     */
-    @Id
-    private String source;
-
-    @ManyToOne
-    @JoinColumn(name = "catalog_id")
-    private CatalogEntity catalog;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/CatalogEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.Data;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-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
- */
-//@Data
-@Getter
-@Setter
-@NoArgsConstructor
-@Entity
-@Table(name = "catalog")
-public class CatalogEntity {
-    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<BibliographyEntity> bibliography;
-
-    /**
-     * Countries
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<CountryEntity> countries;
-
-    /**
-     * Written forms
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<WrittenFormEntity> writtenForms;
-
-    /**
-     * Alternative name
-     */
-    @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
-    @LazyCollection(LazyCollectionOption.FALSE)
-    private Set<AlternativeNameEntity> alternativeNames;
-
-    /**
-     * 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<TypeEntity> types = Collections.emptySet();
-
-    public CatalogEntity(final List<String> csvFields) {
-
-        this.name = csvFields.get(1);
-        List<String> stringList = processListField(csvFields.get(2));
-        this.alternativeNames = new HashSet<>(stringList.size());
-        for (String s : stringList) {
-            this.alternativeNames.add(new AlternativeNameEntity(s, this));
-        }
-        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.size());
-        for (String s : stringList) {
-            this.writtenForms.add(new WrittenFormEntity(s, this));
-        }
-        stringList = processListField(csvFields.get(7));
-        this.types = new HashSet<>(stringList.size());
-        for (String s : stringList) {
-            this.types.add(new TypeEntity(s));
-        }
-        stringList = processListField(csvFields.get(8));
-        this.countries = new HashSet<>(stringList.size());
-        for (String s : stringList) {
-            this.countries.add(new CountryEntity(s, this));
-        }
-        stringList = processListField(csvFields.get(10));
-        this.bibliography = new HashSet<>(stringList.size());
-        for (String s : stringList) {
-            this.bibliography.add(new BibliographyEntity(s, this));
-        }
-    }
-
-    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).collect(Collectors.toList());
-    }
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/CountryEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.persistence.*;
-import java.io.Serializable;
-
-/**
- * Country entity representing country of geographic entry
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "countries")
-@IdClass(CountryEntity.class)
-public class CountryEntity implements Serializable {
-    /**
-     * Name of country, serves as ID
-     */
-    @Id
-    private String name;
-
-    @ManyToOne
-    @JoinColumn(name = "catalog_id")
-    @Id
-    private CatalogEntity catalog;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/Role.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.Getter;
-
-/**
- * Enum for user roles
- */
-@Getter
-public enum Role {
-    ADMIN("ROLE_ADMIN"),
-    USER("ROLE_USER");
-
-    /**
-     * Role
-     */
-    private final String role;
-
-    /**
-     * Creates role
-     *
-     * @param role role
-     */
-    Role(final String role) {
-        this.role = role;
-    }
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/TypeEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.persistence.Entity;
-import javax.persistence.Id;
-import javax.persistence.Table;
-
-/**
- * Type entity representing type of geographic entry
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "types")
-public class TypeEntity {
-    /**
-     * Type (e.g. river), serves as ID
-     */
-    @Id
-    private String type;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/UserEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import org.hibernate.annotations.Type;
-import org.springframework.security.core.GrantedAuthority;
-import org.springframework.security.core.authority.SimpleGrantedAuthority;
-import org.springframework.security.core.userdetails.UserDetails;
-
-import javax.persistence.*;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.UUID;
-
-/**
- * User entity representing application user
- */
-@Data
-@NoArgsConstructor
-@Entity
-@Table(name = "users")
-public class UserEntity implements UserDetails {
-    /**
-     * Name
-     */
-    private String name;
-
-    /**
-     * Email - serves as username and must be unique - serves as Id
-     */
-    @Id
-    private String email;
-
-    /**
-     * Password
-     */
-    private String password;
-
-    /**
-     * Whether the user is admin or not
-     */
-    @Column(name = "is_admin")
-    @Type(type = "numeric_boolean")
-    private boolean isAdmin;
-
-    @Override
-    public Collection<? extends GrantedAuthority> getAuthorities() {
-        final List<GrantedAuthority> authorities = new ArrayList<>();
-        if (isAdmin) {
-            authorities.add(new SimpleGrantedAuthority(Role.ADMIN.getRole()));
-        } else {
-            authorities.add(new SimpleGrantedAuthority(Role.USER.getRole()));
-        }
-
-        return authorities;
-    }
-
-    public String getPassword() {
-        return password;
-    }
-
-    @Override
-    public String getUsername() {
-        return email;
-    }
-
-    @Override
-    public boolean isAccountNonExpired() {
-        return true;
-    }
-
-    @Override
-    public boolean isAccountNonLocked() {
-        return true;
-    }
-
-    @Override
-    public boolean isCredentialsNonExpired() {
-        return true;
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return true;
-    }
-}

backend/src/main/java/cz/zcu/kiv/backendapi/model/WrittenFormEntity.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.model;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.persistence.*;
-import java.io.Serializable;
-
-/**
- * Written form entity representing written form of geographic entry
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "written_forms")
-@IdClass(WrittenFormEntity.class)
-public class WrittenFormEntity implements Serializable {
-    /**
-     * Written form, serves as ID
-     */
-    @Id
-    private String form;
-
-    @ManyToOne
-    @JoinColumn(name = "catalog_id")
-    @Id
-    private CatalogEntity catalog;
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.AlternativeNameEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Alternative name repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface AlternativeNameRepository extends JpaRepository<AlternativeNameEntity, AlternativeNameEntity> {
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.BibliographyEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Bibliography repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface BibliographyRepository extends JpaRepository<BibliographyEntity, BibliographyEntity> {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/repo/CatalogRepository.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.CatalogEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.UUID;
-
-/**
- * Catalog repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface CatalogRepository extends JpaRepository<CatalogEntity, UUID> {
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.CountryEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Country repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface CountryRepository extends JpaRepository<CountryEntity, CountryEntity> {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/repo/TypeRepository.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.TypeEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-
-/**
- * Type repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface TypeRepository extends JpaRepository<TypeEntity, String> {
-}

backend/src/main/java/cz/zcu/kiv/backendapi/repo/UserRepository.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.UserEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-
-/**
- * User repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface UserRepository extends JpaRepository<UserEntity, String> {
-}

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

@@ -1 @@
-package cz.zcu.kiv.backendapi.repo;
-
-import cz.zcu.kiv.backendapi.model.WrittenFormEntity;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * Written form repository
- */
-@Repository
-@Transactional(readOnly = true)
-public interface WrittenFormRepository extends JpaRepository<WrittenFormEntity, WrittenFormEntity> {
-}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.security;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+
+/**
+ * Class representing password encoder
+ */
+@Configuration
+public class PasswordEncoder {
+
+    /**
+     * Returns password encoder
+     *
+     * @return password encoder
+     */
+    @Bean
+    public BCryptPasswordEncoder bCryptPasswordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.security;
+
+import cz.zcu.kiv.backendapi.security.jwt.JwtUtils;
+import cz.zcu.kiv.backendapi.security.jwt.JwtTokenVerifier;
+import cz.zcu.kiv.backendapi.security.jwt.JwtUsernameAndPasswordAuthenticationFilter;
+import cz.zcu.kiv.backendapi.user.Permission;
+import cz.zcu.kiv.backendapi.user.Role;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+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;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+
+/**
+ * Security config class
+ */
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+    /**
+     * User detail service
+     */
+    private final UserDetailsService userDetailsService;
+
+    /**
+     * Password encoder
+     */
+    private final BCryptPasswordEncoder bCryptPasswordEncoder;
+
+    /**
+     * JWT utils
+     */
+    private final JwtUtils jwtUtils;
+
+    /**
+     * List of permitted pages without login
+     */
+    private final String[] permittedUrls = new String[]{"/login", "/token/refresh"};
+
+    /**
+     * Security configuration
+     *
+     * @param http http security
+     * @throws Exception exception
+     */
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http.
+                csrf().disable()
+                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+                .and()
+                .authorizeRequests()
+                .antMatchers("/login").permitAll()
+                .antMatchers(permittedUrls).permitAll()
+                .antMatchers("/admin/**").hasRole(Role.ADMIN.name())
+                .antMatchers("/write/**").hasAuthority(Permission.WRITE.name())
+                .antMatchers("/read/**").hasAuthority(Permission.READ.name())
+                .antMatchers("/delete/**").hasAuthority(Permission.DELETE.name())
+                .anyRequest()
+                .authenticated()
+                .and()
+                .addFilter(new JwtUsernameAndPasswordAuthenticationFilter(authenticationManager(), jwtUtils))
+                .addFilterAfter(new JwtTokenVerifier(jwtUtils, permittedUrls), JwtUsernameAndPasswordAuthenticationFilter.class);
+    }
+
+    /**
+     * Sets authentication provider to authentication manager
+     *
+     * @param auth authentication manager builder
+     */
+    @Override
+    protected void configure(final AuthenticationManagerBuilder auth) {
+        auth.authenticationProvider(authenticationProvider());
+    }
+
+
+    /**
+     * Returns authentication provider
+     *
+     * @return authentication provider
+     */
+    @Bean
+    public DaoAuthenticationProvider authenticationProvider() {
+        final DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
+        provider.setUserDetailsService(userDetailsService);
+        provider.setPasswordEncoder(bCryptPasswordEncoder);
+        return provider;
+    }
+
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.security.jwt;
+
+import com.auth0.jwt.JWT;
+import com.auth0.jwt.JWTVerifier;
+import com.auth0.jwt.algorithms.Algorithm;
+import com.auth0.jwt.interfaces.DecodedJWT;
+import com.google.common.base.Strings;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpHeaders;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+/**
+ * Class that verifies JWT per request
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class JwtTokenVerifier extends OncePerRequestFilter {
+
+    /**
+     * JWT utils
+     */
+    private final JwtUtils jwtUtils;
+
+    /**
+     * Array or urls with this filter (JWT not needed for them)
+     */
+    private final String[] skipFilterUrls;
+
+    /**
+     * Filters request - checks for JWT token and validates it
+     *