Revize abaa5f46

Experiment with database

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

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