/ - Diff - Zpracování geografických údajů v novoasyrských textech (KBS FF) - Code of Duty - Redmine

     package cz.zcu.kiv.backendapi.alternativename;
     import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
     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(AlternativeName.class)
     public class AlternativeName implements Serializable {
         /**
          * Name, serves as ID
          */
         @Id
         private String name;
         /**
          * Catalog entity
          */
         @ManyToOne
         @JoinColumn(name = "catalog_id")
         @Id
         private CatalogEntry catalog;
+    }

     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
9	9	*/
10	10	@Repository
11	11	@Transactional(readOnly = true)
12		public interface AlternativeNameRepository extends JpaRepository<AlternativeNameEntity, AlternativeNameEntity> {
	12	public interface AlternativeNameRepository extends JpaRepository<AlternativeName, AlternativeName> {
13	13	}

     package cz.zcu.kiv.backendapi.bibliography;
     import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
     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(Bibliography.class)
     public class Bibliography implements Serializable {
         /**
          * Source, serves as ID
          */
         @Id
         private String source;
         @ManyToOne
         @JoinColumn(name = "catalog_id")
         private CatalogEntry catalog;
+    }

     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
9	9	*/
10	10	@Repository
11	11	@Transactional(readOnly = true)
12		public interface BibliographyRepository extends JpaRepository<BibliographyEntity, BibliographyEntity> {
	12	public interface BibliographyRepository extends JpaRepository<Bibliography, Bibliography> {
13	13	}

         /**
          * Catalog service
          */
         private final ICatalogService catalogService;
         private final ICatalogEntryService catalogService;
         /**
          * Saves new catalog entry
+         *
          * @param catalogEntryDto catalog entry DTO
          */
         @PostMapping("")
         public void addCatalogEntry(@RequestBody CatalogDto catalogDto) {
             catalogService.saveCatalogEntry(catalogDto);
         public void addCatalogEntry(@RequestBody CatalogEntryDto catalogEntryDto) {
             catalogService.saveCatalogEntry(catalogEntryDto);
+        }
         /**
-...
          * @return list of catalog entries satisfying given filter
          */
         @GetMapping("")
         public ResponseEntity<List<CatalogDto>> getCatalog(@RequestParam(defaultValue = "") String name, @RequestParam(defaultValue = "") String country, @RequestParam(defaultValue = "") String type) {
         public ResponseEntity<List<CatalogEntryDto>> 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
+         *
          * @param id         ID
          * @param catalogDto catalog DTO
          * @param id              ID
          * @param catalogEntryDto catalog DTO
          */
         @PutMapping("/{id}")
         public void updateCatalogEntry(@PathVariable UUID id, @RequestBody CatalogDto catalogDto) {
             catalogService.updateCatalogEntry(id, catalogDto);
         public void updateCatalogEntry(@PathVariable UUID id, @RequestBody CatalogEntryDto catalogEntryDto) {
             catalogService.updateCatalogEntry(id, catalogEntryDto);
+        }
         /**

     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 DTO
      */
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class CatalogDto {
         /**
          * 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();
+    }

     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 = Collections.emptySet();
         /**
          * Countries
          */
         @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
         @LazyCollection(LazyCollectionOption.FALSE)
         private Set<CountryEntity> countries = Collections.emptySet();
         /**
          * Written forms
          */
         @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
         @LazyCollection(LazyCollectionOption.FALSE)
         private Set<WrittenFormEntity> writtenForms = Collections.emptySet();
         /**
          * Alternative names
          */
         @OneToMany(mappedBy = "catalog", cascade = CascadeType.ALL)
         @LazyCollection(LazyCollectionOption.FALSE)
         private Set<AlternativeNameEntity> 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<TypeEntity> types = Collections.emptySet();
         public CatalogEntity(final List<String> csvFields) {
             this.name = csvFields.get(1);
             List<String> stringList = processListField(csvFields.get(2));
             this.alternativeNames = stringList.stream().map(s->new AlternativeNameEntity(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 WrittenFormEntity(s, this)).collect(Collectors.toSet());
             stringList = processListField(csvFields.get(7));
             this.types = stringList.stream().map(TypeEntity::new).collect(Collectors.toSet());
             stringList = processListField(csvFields.get(8));
             this.countries = stringList.stream().map(s->new CountryEntity(s, this)).collect(Collectors.toSet());
             stringList = processListField(csvFields.get(10));
             this.bibliography = stringList.stream().map(s->new BibliographyEntity(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());
+        }
+    }

     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.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 entry
      */
     //@Data
     @Getter
     @Setter
     @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());
+        }
+    }

     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();
+    }

     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.Set;
     import java.util.UUID;
     /**
      * Catalog repository
      */
     @Repository
     @Transactional(readOnly = true)
     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 e.name LIKE ?1 OR a.name LIKE ?1) " +
                 "AND (?2 = '' OR c.name LIKE ?2) " +
                 "AND (?3 = '' OR t.type LIKE ?3)")
         Set<CatalogEntry> filterCatalog(String name, String country, String type);
+    }

     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.Type;
     import cz.zcu.kiv.backendapi.type.ITypeService;
     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 {
         /**
          * 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) {
             CatalogEntry catalogEntry = catalogEntryRepository.findById(id).orElseThrow(() -> {
                 log.error(CATALOG_ENTRY_NOT_FOUND);
                 throw new ApiRequestException(CATALOG_ENTRY_NOT_FOUND, HttpStatus.NOT_FOUND);
             });
             catalogEntryRepository.delete(catalogEntry);
             log.info("Catalog entry deleted");
+        }
         @Override
         public List<CatalogEntryDto> getCatalog(String name, String country, String type) {
             log.info("Retrieving catalog");
             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;
+        }
+    }

     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.Set;
     import java.util.UUID;
     /**
      * Catalog repository
      */
     @Repository
     @Transactional(readOnly = true)
     public interface CatalogRepository extends JpaRepository<CatalogEntity, 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 CatalogEntity e LEFT JOIN AlternativeNameEntity a ON e = a.catalog " +
                 "LEFT JOIN CountryEntity c ON e = c.catalog " +
                 "INNER JOIN e.types t " +
                 "WHERE (?1 = '' OR e.name LIKE ?1 OR a.name LIKE ?1) " +
                 "AND (?2 = '' OR c.name LIKE ?2) " +
                 "AND (?3 = '' OR t.type LIKE ?3)")
         Set<CatalogEntity> filterCatalog(String name, String country, String type);
+    }

     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.exception.ApiRequestException;
     import cz.zcu.kiv.backendapi.type.TypeEntity;
     import cz.zcu.kiv.backendapi.type.ITypeService;
     import cz.zcu.kiv.backendapi.writtenform.WrittenFormEntity;
     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 service implementation
      */
     @Service
     @Transactional
     @RequiredArgsConstructor
     @Slf4j
     public class CatalogServiceImpl implements ICatalogService {
         /**
          * 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 CatalogRepository catalogRepository;
         /**
          * Type service
          */
         private final ITypeService typeService;
         @Override
         public void saveCatalog(List<CatalogEntity> catalogEntities) {
             log.info("Saving catalog");
             catalogEntities.forEach(this::saveCatalogEntity);
+        }
         @Override
         public void saveCatalogEntry(CatalogDto catalogDto) {
             log.info("Saving catalog entry");
             CatalogEntity catalogEntity = new CatalogEntity();
             convertDtoToEntity(catalogDto, catalogEntity);
             saveCatalogEntity(catalogEntity);
+        }
         @Override
         public void updateCatalogEntry(UUID id, CatalogDto catalogDto) {
             CatalogEntity catalogEntity = catalogRepository.findById(id).orElseThrow(() -> {
                 log.error(CATALOG_ENTRY_NOT_FOUND);
                 throw new ApiRequestException(CATALOG_ENTRY_NOT_FOUND, HttpStatus.NOT_FOUND);
             });
             convertDtoToEntity(catalogDto, catalogEntity);
             saveCatalogEntity(catalogEntity);
             log.info("Catalog entry updated");
+        }
         @Override
         public void deleteCatalogEntry(UUID id) {
             CatalogEntity catalogEntity = catalogRepository.findById(id).orElseThrow(() -> {
                 log.error(CATALOG_ENTRY_NOT_FOUND);
                 throw new ApiRequestException(CATALOG_ENTRY_NOT_FOUND, HttpStatus.NOT_FOUND);
             });
             catalogRepository.delete(catalogEntity);
             log.info("Catalog entry deleted");
+        }
         @Override
         public List<CatalogDto> getCatalog(String name, String country, String type) {
             log.info("Retrieving catalog");
             Set<CatalogEntity> entities = catalogRepository.filterCatalog(name, country, type);
             return entities.stream().map(this::convertEntityToDto).collect(Collectors.toList());
+        }
         /**
          * Saves catalog entity to database
+         *
          * @param catalogEntity catalog entity
          */
         private void saveCatalogEntity(CatalogEntity catalogEntity) {
             for (TypeEntity type : catalogEntity.getTypes()) {
                 if (typeService.getTypeByName(type.getType()).isEmpty()) {
                     typeService.saveType(type);
+                }
+            }
             catalogRepository.save(catalogEntity);
+        }
         /**
          * Converts catalog DTO to catalog entity
+         *
          * @param catalogDto    catalog DTO
          * @param catalogEntity catalog entity
          */
         private void convertDtoToEntity(CatalogDto catalogDto, CatalogEntity catalogEntity) {
             catalogEntity.setName(catalogDto.getName());
             catalogEntity.setCertainty(catalogDto.getCertainty());
             catalogEntity.setLatitude(catalogDto.getLatitude());
             catalogEntity.setLongitude(catalogDto.getLongitude());
             catalogEntity.setBibliography(catalogDto.getBibliography()
                     .stream().map(s -> new BibliographyEntity(s, catalogEntity)).collect(Collectors.toSet()));
             catalogEntity.setTypes(catalogDto.getTypes()
                     .stream().map(TypeEntity::new).collect(Collectors.toSet()));
             catalogEntity.setCountries(catalogDto.getCountries()
                     .stream().map(s -> new CountryEntity(s, catalogEntity)).collect(Collectors.toSet()));
             catalogEntity.setAlternativeNames(catalogDto.getAlternativeNames()
                     .stream().map(s -> new AlternativeNameEntity(s, catalogEntity)).collect(Collectors.toSet()));
             catalogEntity.setWrittenForms(catalogDto.getWrittenForms()
                     .stream().map(s -> new WrittenFormEntity(s, catalogEntity)).collect(Collectors.toSet()));
+        }
         /**
          * Converts catalog entity to catalog DTO
+         *
          * @param entity catalog entity
          * @return catalog DTO
          */
         private CatalogDto convertEntityToDto(CatalogEntity entity) {
             CatalogDto catalogDto = new CatalogDto();
             catalogDto.setId(entity.getId());
             catalogDto.setName(entity.getName());
             catalogDto.setLatitude(entity.getLatitude());
             catalogDto.setLongitude(entity.getLongitude());
             catalogDto.setCertainty(entity.getCertainty());
             catalogDto.setBibliography(entity.getBibliography()
                     .stream().map(BibliographyEntity::getSource).collect(Collectors.toSet()));
             catalogDto.setTypes(entity.getTypes()
                     .stream().map(TypeEntity::getType).collect(Collectors.toSet()));
             catalogDto.setCountries(entity.getCountries()
                     .stream().map(CountryEntity::getName).collect(Collectors.toSet()));
             catalogDto.setAlternativeNames(entity.getAlternativeNames()
                     .stream().map(AlternativeNameEntity::getName).collect(Collectors.toSet()));
             catalogDto.setWrittenForms(entity.getWrittenForms()
                     .stream().map(WrittenFormEntity::getForm).collect(Collectors.toSet()));
             return catalogDto;
+        }
+    }

     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);
+    }

     package cz.zcu.kiv.backendapi.catalog;
     import java.util.List;
     import java.util.UUID;
     /**
      * Catalog service interface
      */
     public interface ICatalogService {
         /**
          * Saves list of catalog entries
+         *
          * @param catalogEntities catalog entris
          */
         void saveCatalog(List<CatalogEntity> catalogEntities);
         /**
          * Saves one catalog entry
+         *
          * @param catalogDto catalog DTO
          */
         void saveCatalogEntry(CatalogDto catalogDto);
         /**
          * Updates catalog entry with given ID
+         *
          * @param id         ID
          * @param catalogDto catalog DTO
          */
         void updateCatalogEntry(UUID id, CatalogDto catalogDto);
         /**
          * 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<CatalogDto> getCatalog(String name, String country, String type);
+    }

     package cz.zcu.kiv.backendapi.config;
     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.catalog.CatalogEntry;
     import cz.zcu.kiv.backendapi.type.Type;
     import cz.zcu.kiv.backendapi.catalog.CatalogEntryRepository;
     import cz.zcu.kiv.backendapi.catalog.ICatalogEntryService;
     import cz.zcu.kiv.backendapi.type.ITypeService;
     import cz.zcu.kiv.backendapi.user.UserEntity;
     import cz.zcu.kiv.backendapi.user.UserRepository;
-...
     @RequiredArgsConstructor
     public class DataInitiator implements ApplicationListener<ContextRefreshedEvent> {
         private final ICatalogService catalogService;
         private final ICatalogEntryService catalogService;
         private final ITypeService typeService;
         private final CatalogRepository catalogRepository;
         private final CatalogEntryRepository catalogEntryRepository;
         private final UserRepository userRepository;
-...
         @Override
         @Transactional
         public void onApplicationEvent(ContextRefreshedEvent event) {
             List<TypeEntity> types = loadTypes();
             List<Type> types = loadTypes();
             typeService.saveTypes(types);
             List<CatalogEntity> catalog = loadCatalog();
             List<CatalogEntry> catalog = loadCatalog();
             catalogService.saveCatalog(catalog);
             UserEntity user1 = new UserEntity("admin", "admin", encoder.encode("password"), (byte) 7, true);
-...
+        }
         private List<CatalogEntity> loadCatalog() {
             List<CatalogEntity> catalogEntities = new ArrayList<>();
             File csvData = new File("AssyrianProject-AllNoDupl.csv");
         private List<CatalogEntry> loadCatalog() {
             List<CatalogEntry> catalogEntities = new ArrayList<>();
             File csvData = new File("AssyrianProject-AllNoDupl-22-03-28.csv");
             CSVParser parser;
             try {
                 parser = CSVParser.parse(csvData, StandardCharsets.UTF_8, CSVFormat.Builder.create(CSVFormat.DEFAULT)
-...
                         .setSkipHeaderRecord(true)
                         .build());
                 for (CSVRecord csvRecord : parser) {
                     catalogEntities.add(new CatalogEntity(csvRecord.toList()));
                     catalogEntities.add(new CatalogEntry(csvRecord.toList()));
+                }
             } catch (IOException e) {
                 e.printStackTrace();
-...
+        }
         private List<TypeEntity> loadTypes() {
             List<TypeEntity> types = new ArrayList<>();
         private List<Type> loadTypes() {
             List<Type> 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)));
                         types.add(new Type(csvRecord.get(2)));
+                    }
+                }
             } catch (IOException e) {

     package cz.zcu.kiv.backendapi.country;
     import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
     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(Country.class)
     public class Country implements Serializable {
         /**
          * Name of country, serves as ID
          */
         @Id
         private String name;
         @ManyToOne
         @JoinColumn(name = "catalog_id")
         @Id
         private CatalogEntry catalog;
+    }

     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
9	9	*/
10	10	@Repository
11	11	@Transactional(readOnly = true)
12		public interface CountryRepository extends JpaRepository<CountryEntity, CountryEntity> {
	12	public interface CountryRepository extends JpaRepository<Country, Country> {
13	13	}

backend/src/main/java/cz/zcu/kiv/backendapi/exception/ApiRequestException.java
12	12	this.httpStatus = httpStatus;
13	13	}
14	14
15		public ApiRequestException(String message, Throwable cause, HttpStatus httpStatus) {
16		super(message, cause);
17		this.httpStatus = httpStatus;
18		}
19	15	}

     package cz.zcu.kiv.backendapi.password;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import cz.zcu.kiv.backendapi.validation.PasswordMatches;
     import lombok.Data;
     import lombok.NoArgsConstructor;
     import javax.validation.constraints.NotEmpty;
     import javax.validation.constraints.NotNull;
     import javax.validation.constraints.Size;
     /**
      * Password data object
      */
     @Data
     @PasswordMatches
     @NoArgsConstructor
     public class PasswordDto {
         /**
          * Minimal length for password
          */
         @JsonIgnore
         private  static final int MIN_PASSWORD_LENGTH = 8;
         /**
          * New password - must be strong enough
          */
         @NotNull(message = "Password must not be null")
         @NotEmpty(message = "Password must not be empty")
         @Size(min = MIN_PASSWORD_LENGTH, message = "Password must be at least " + MIN_PASSWORD_LENGTH + " characters long")
         private String password;
         /**
          * New password confirmation - must match new password
          */
         @NotNull(message = "Confirmation password must not be null")
         @NotEmpty(message = "Confirmation password must not be empty")
         private String confirmationPassword;
+    }

     import lombok.RequiredArgsConstructor;
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;
     import org.springframework.http.HttpMethod;
     import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
     import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
     import org.springframework.security.config.annotation.web.builders.HttpSecurity;
-...
                     .and()
                     .authorizeRequests()
                     .antMatchers(permittedUrls).permitAll()
                     .antMatchers("/admin/**").hasRole(Role.ADMIN.name())
                     .antMatchers("/user/update-permissions/**", "/user/reset-password/**").hasRole(Role.ADMIN.name())
                     .antMatchers(HttpMethod.DELETE, "/user/**").hasRole(Role.ADMIN.name())
                     .antMatchers("/write/**").hasAuthority(Permission.WRITE.name())
                     .antMatchers("/read/**").hasAuthority(Permission.READ.name())
                     .antMatchers("/delete/**").hasAuthority(Permission.DELETE.name())

          * Claim authorities name
          */
         private String claimAuthoritiesName;
         public JwtUtils() {
+        }
         /**
          * Returns algorithm for JWT

      */
     public interface ITypeService {
         void saveType(TypeEntity typeEntity);
         void saveType(Type type);
         void saveTypes(List<TypeEntity> typesEntities);
         void saveTypes(List<Type> typesEntities);
         Optional<TypeEntity> getTypeByName(String type);
         Optional<Type> getTypeByName(String type);
+    }

     package cz.zcu.kiv.backendapi.type;
     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 Type {
         /**
          * Type (e.g. river), serves as ID
          */
         @Id

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2022 » Zpracování geografických údajů v novoasyrských textech (KBS FF) - Code of Duty

Revize b2af5445

Přidáno uživatelem Jakub Šmíd před více než 2 roky(ů)