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

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