Revize fb55e8e9

Catalog change
- one-to-many associations now persist order
- text for search persists separators

re #9751
re #9754

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

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.catalog;
 
-import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
+import cz.zcu.kiv.backendapi.alternativename.CatalogItemName;
 import cz.zcu.kiv.backendapi.bibliography.Bibliography;
 import cz.zcu.kiv.backendapi.country.Country;
 import cz.zcu.kiv.backendapi.type.Type;
@@ -16 +16 @@
 
 import javax.persistence.*;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /**
- * Catalog entity representing catalog item
+ * Catalog item entity representing catalog item
  */
 @Getter
 @Setter
@@ -73 +74 @@
     @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<Bibliography> bibliography = new HashSet<>();
+    @OrderBy("entryOrder")
+    private Set<Bibliography> bibliography = new LinkedHashSet<>(0);
 
     /**
      * Countries
@@ -81 +83 @@
     @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<Country> countries = new HashSet<>();
+    @OrderBy("entryOrder")
+    private Set<Country> countries = new LinkedHashSet<>(0);
 
     /**
      * Written forms
@@ -89 +92 @@
     @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<WrittenForm> writtenForms = new HashSet<>();
+    @OrderBy("entryOrder")
+    private Set<WrittenForm> writtenForms = new LinkedHashSet<>(0);
 
     /**
-     * Alternative names
+     * All names
      */
     @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
     @LazyCollection(LazyCollectionOption.FALSE)
     @Fetch(FetchMode.SUBSELECT)
-    private Set<AlternativeName> alternativeNames = new HashSet<>();
+    @OrderBy("entryOrder")
+    private Set<CatalogItemName> allNames = new LinkedHashSet<>(0);
 
     /**
      * Set of user roles - many-to-many relationship
@@ -113 +118 @@
                     @JoinColumn(name = "type", referencedColumnName = "type")
             }
     )
-    private Set<Type> types = new HashSet<>();
+    private Set<Type> types = new LinkedHashSet<>(0);
 
     public CatalogItem(List<String> csvFields) {
+        AtomicInteger counter = new AtomicInteger(1);
 
         this.name = csvFields.get(1);
-        Set<String> stringList = processListField(csvFields.get(2));
-        stringList.add(this.name);
-        this.alternativeNames = stringList.stream().map(s -> new AlternativeName(s, this)).collect(Collectors.toSet());
+        Set<String> stringLinkedSet = new LinkedHashSet<>();
+        stringLinkedSet.add(this.name);
+        stringLinkedSet.addAll(processListField(csvFields.get(2)));
+        this.allNames = stringLinkedSet.stream().map(s -> new CatalogItemName(s, this, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new));
 
         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());
+        stringLinkedSet = processListField(csvFields.get(6));
+        counter.set(1);
+        this.writtenForms = stringLinkedSet.stream().map(s -> new WrittenForm(s, this, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new));
 
-        stringList = processListField(csvFields.get(7));
-        this.types = stringList.stream().map(Type::new).collect(Collectors.toSet());
+        stringLinkedSet = processListField(csvFields.get(7));
+        this.types = stringLinkedSet.stream().map(Type::new).collect(Collectors.toCollection(LinkedHashSet::new));
 
-        stringList = processListField(csvFields.get(8));
-        this.countries = stringList.stream().map(s -> new Country(s, this)).collect(Collectors.toSet());
+        stringLinkedSet = processListField(csvFields.get(8));
+        counter.set(1);
+        this.countries = stringLinkedSet.stream().map(s -> new Country(s, this, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new));
 
-        stringList = processListField(csvFields.get(9));
-        this.bibliography = stringList.stream().map(s -> new Bibliography(s, this)).collect(Collectors.toSet());
+        stringLinkedSet = processListField(csvFields.get(9));
+        counter.set(1);
+        this.bibliography = stringLinkedSet.stream().map(s -> new Bibliography(s, this, counter.getAndIncrement())).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     private Integer processIntField(String field) {
@@ -159 +169 @@
 
     private Set<String> processListField(String field) {
         if (field.isEmpty() || field.equals(EMPTY_ENTRY)) {
-            return new HashSet<>();
+            return new LinkedHashSet<>();
         }
-        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toSet());
+        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 }