Revize 45d0c4d7

Added entities
- connected to Postgres database
- created repositories and services for entities
- created setup for given csv catalog data
re #9191
re #9099

backend/pom.xml

@@ -14 +14 @@
     <name>backend-api</name>
     <description>Backend API for Neo-assyrian web application</description>
     <properties>
-        <java.version>17</java.version>
+        <java.version>11</java.version>
     </properties>
     <dependencies>
         <dependency>
@@ -32 +32 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+
+
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-csv</artifactId>
+            <version>1.9.0</version>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -13 +13 @@
         LOGGER.info("StubController initialized!");
     }
 
-    @GetMapping("/stub")
-    public StubDto getStubDto() {
-        return new StubDto("Hello API", true);
-    }
+//    @GetMapping("/stub")
+//    public StubDto getStubDto() {
+//        return new StubDto("Hello API", true);
+//    }
 }

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

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi;
 
-
-import lombok.AllArgsConstructor;
-public record StubDto(String message, Boolean success) {}
+//
+//import lombok.AllArgsConstructor;
+//public record StubDto(String message, Boolean success) {}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.config;
+
+import cz.zcu.kiv.backendapi.model.CatalogEntity;
+import cz.zcu.kiv.backendapi.service.catalog.ICatalogService;
+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.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+//TODO comment or delete
+@Component
+@RequiredArgsConstructor
+public class DataInitiator implements ApplicationListener<ContextRefreshedEvent> {
+
+    private final ICatalogService catalogService;
+
+    @Override
+    @Transactional
+    public void onApplicationEvent(ContextRefreshedEvent event) {
+        List<CatalogEntity> catalog = loadCatalog();
+        catalogService.saveCatalog(catalog);
+
+    }
+
+    private List<CatalogEntity> loadCatalog() {
+        List<CatalogEntity> catalogEntities = new ArrayList<>();
+        File csvData = new File("AssyrianProject-AllNoDupl.csv");
+        CSVParser parser;
+        try {
+            parser = CSVParser.parse(csvData, StandardCharsets.UTF_8, CSVFormat.Builder.create(CSVFormat.DEFAULT)
+                    .setHeader()
+                    .setSkipHeaderRecord(true)
+                    .build());
+            for (CSVRecord csvRecord : parser) {
+                catalogEntities.add(new CatalogEntity(csvRecord.toList()));
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return catalogEntities;
+
+    }
+}

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/service/alternativename/AlternativeNameServiceImpl.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.alternativename;
+
+import cz.zcu.kiv.backendapi.repo.AlternativeNameRepository;
+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/service/alternativename/IAlternativeNameService.java

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

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.bibliography;
+
+import cz.zcu.kiv.backendapi.repo.BibliographyRepository;
+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/service/bibliography/IBibliographyService.java

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

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.catalog;
+
+import cz.zcu.kiv.backendapi.model.CatalogEntity;
+import cz.zcu.kiv.backendapi.model.TypeEntity;
+import cz.zcu.kiv.backendapi.repo.CatalogRepository;
+import cz.zcu.kiv.backendapi.service.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/service/catalog/ICatalogService.java

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

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.country;
+
+import cz.zcu.kiv.backendapi.repo.CountryRepository;
+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/service/country/ICountryService.java

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

backend/src/main/java/cz/zcu/kiv/backendapi/service/type/ITypeService.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.type;
+
+import cz.zcu.kiv.backendapi.model.TypeEntity;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Type service interface
+ */
+public interface ITypeService {
+
+    void saveType(TypeEntity typeEntity);
+
+    void saveTypes(List<TypeEntity> typesEntities);
+
+    Optional<TypeEntity> getTypeByName(String type);
+}

backend/src/main/java/cz/zcu/kiv/backendapi/service/type/TypeServiceImpl.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.type;
+
+import cz.zcu.kiv.backendapi.model.TypeEntity;
+import cz.zcu.kiv.backendapi.repo.TypeRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Type service implementation
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class TypeServiceImpl implements ITypeService {
+    /**
+     * Type repository
+     */
+    private final TypeRepository typeRepository;
+
+    @Override
+    public void saveType(TypeEntity typeEntity) {
+        typeRepository.save(typeEntity);
+    }
+
+    @Override
+    public void saveTypes(List<TypeEntity> typesEntities) {
+        typeRepository.saveAll(typesEntities);
+    }
+
+    @Override
+    public Optional<TypeEntity> getTypeByName(String type) {
+        return typeRepository.findById(type);
+    }
+
+
+}

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.user;
+
+/**
+ * User service interface
+ */
+public interface IUserService {
+}

backend/src/main/java/cz/zcu/kiv/backendapi/service/user/UserServiceImpl.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.user;
+
+import cz.zcu.kiv.backendapi.repo.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * User service implementation
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class UserServiceImpl implements IUserService {
+    /**
+     * User repository
+     */
+    private final UserRepository userRepository;
+
+//    /**
+//     * Password encoder
+//     */
+    // TODO bean
+//    private final BCryptPasswordEncoder passwordEncoder;
+}

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

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

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.service.writtenform;
+
+import cz.zcu.kiv.backendapi.repo.WrittenFormRepository;
+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

@@ +1 @@
+spring.datasource.url=jdbc:postgresql://localhost:5432/test
+spring.datasource.username=test
+spring.datasource.password=Password.123
 
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.generate-ddl=true
+spring.jpa.open-in-view=false
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect
+spring.jpa.properties.hibernate.format_sql=true
+spring.jpa.show-sql=true