aswi2022code-of-duty-gitlab/backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogItem.java @ cf12d561

package cz.zcu.kiv.backendapi.catalog;

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;
import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
import lombok.EqualsAndHashCode;
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.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * Catalog item entity representing catalog item
 */
@Getter
@Setter
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
@NoArgsConstructor
@Entity
@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
     */
    @Id
    @EqualsAndHashCode.Include
    private UUID id = UUID.randomUUID();

    /**
     * Name of geographic item
     */
    private String name = "";

    /**
     * Certainty
     */
    private Integer certainty;

    /**
     * Longitude
     */
    private Double longitude;

    /**
     * Latitude
     */
    private Double latitude;

    /**
     * Description
     */
    @Column(length = 100000)
    private String description = "";

    /**
     * Bibliography
     */
    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    @LazyCollection(LazyCollectionOption.FALSE)
    @Fetch(FetchMode.SUBSELECT)
    @OrderBy("entryOrder")
    private Set<Bibliography> bibliography = new LinkedHashSet<>(0);

    /**
     * Countries
     */
    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    @LazyCollection(LazyCollectionOption.FALSE)
    @Fetch(FetchMode.SUBSELECT)
    @OrderBy("entryOrder")
    private Set<Country> countries = new LinkedHashSet<>(0);

    /**
     * Written forms
     */
    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    @LazyCollection(LazyCollectionOption.FALSE)
    @Fetch(FetchMode.SUBSELECT)
    @OrderBy("entryOrder")
    private Set<WrittenForm> writtenForms = new LinkedHashSet<>(0);

    /**
     * All names
     */
    @OneToMany(mappedBy = "catalogItem", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    @LazyCollection(LazyCollectionOption.FALSE)
    @Fetch(FetchMode.SUBSELECT)
    @OrderBy("entryOrder")
    private Set<CatalogItemName> allNames = new LinkedHashSet<>(0);

    /**
     * Set of user roles - many-to-many relationship
     */
    @ManyToMany(fetch = FetchType.EAGER)
    @Fetch(FetchMode.SUBSELECT)
    @JoinTable(
            name = "catalog_item_type",
            joinColumns = {
                    @JoinColumn(name = "catalog_item_id", referencedColumnName = "id")
            },
            inverseJoinColumns = {
                    @JoinColumn(name = "type", referencedColumnName = "type")
            }
    )
    private Set<Type> types = new LinkedHashSet<>(0);

    public CatalogItem(List<String> csvFields) {
        AtomicInteger counter = new AtomicInteger(1);

        this.name = csvFields.get(1);
        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));

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

        stringLinkedSet = processListField(csvFields.get(7));
        this.types = stringLinkedSet.stream().map(Type::new).collect(Collectors.toCollection(LinkedHashSet::new));

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

        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) {
        Matcher matcher = Pattern.compile(INTEGER_PATTERN).matcher(field);
        if (matcher.find()) {
            return Integer.parseInt(matcher.group());
        } else {
            return null;
        }
    }

    private Double processDoubleField(String field) {
        Matcher matcher = Pattern.compile(DOUBLE_PATTERN).matcher(field);
        if (matcher.find()) {
            return Double.parseDouble(matcher.group());
        } else {
            return null;
        }
    }

    private Set<String> processListField(String field) {
        if (field.isEmpty() || field.equals(EMPTY_ENTRY)) {
            return new LinkedHashSet<>();
        }
        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toCollection(LinkedHashSet::new));
    }
}