aswi2022code-of-duty-gitlab/backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalCatalogItem.java @ e21b7441

package cz.zcu.kiv.backendapi.external;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * Class representing external catalog items
 */
@Getter
@Setter
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
@NoArgsConstructor
@Entity
@Table(name = "external_catalog_items")
public class ExternalCatalogItem {
    /**
     * Map where key is country code and value is name of country
     */
    protected static final Map<String, String> COUNTRY_CODES;

    /**
     * Integer pattern for finding int value in string
     */
    private static final Pattern INTEGER_PATTERN = Pattern.compile("\\d+");

    /**
     * Double pattern for finding double value in string
     */
    private static final Pattern DOUBLE_PATTERN = Pattern.compile("(\\d+[.]\\d+)|(\\d+)");

    static {
        COUNTRY_CODES = new LinkedHashMap<>();
        COUNTRY_CODES.put("IQ", "Iraq");
        COUNTRY_CODES.put("IR", "Iran");
        COUNTRY_CODES.put("SY", "Syria");
        COUNTRY_CODES.put("TR", "Turkey");
        COUNTRY_CODES.put("JO", "Jordan");
        COUNTRY_CODES.put("LB", "Lebanon");
        COUNTRY_CODES.put("IL", "Israel");
        COUNTRY_CODES.put("PS", "Palestine");
        COUNTRY_CODES.put("CY", "Cyprus");
        COUNTRY_CODES.put("EG", "Egypt");
        COUNTRY_CODES.put("SD", "Sudan");
        COUNTRY_CODES.put("BH", "Bahrain");
        COUNTRY_CODES.put("KW", "Kuwait");
        COUNTRY_CODES.put("OM", "Oman");
        COUNTRY_CODES.put("SA", "Saudi Arabia");
        COUNTRY_CODES.put("AE", "United Arab Emirates");
        COUNTRY_CODES.put("YE", "Yemen");
        COUNTRY_CODES.put("AF", "Afghanistan");
        COUNTRY_CODES.put("AM", "Armenia");
        COUNTRY_CODES.put("GE", "Georgia");
    }

    /**
     * Id
     */
    @Id
    @EqualsAndHashCode.Include
    UUID id = UUID.randomUUID();

    /**
     * External source
     */
    @Enumerated(EnumType.STRING)
    private ExternalSource externalSource;

    /**
     * Latitude
     */
    private Double latitude;

    /**
     * Longitude
     */
    private Double longitude;

    /**
     * Precision of location
     */
    private String locationPrecision;

    /**
     * Max date
     */
    private Integer maxDate;

    /**
     * Min date
     */
    private Integer minDate;

    /**
     * Keys for time periods
     */
    @Column(length = 1000)
    private String timePeriodKeys;

    /**
     * Pid
     */
    private String pid;

    /**
     * Set of names
     */
    @Convert(converter = SetToStringConverter.class)
    @Column(length = 20000)
    private Set<String> names = new HashSet<>();

    /**
     * Feature code
     */
    private String featureCode;

    /**
     * Country
     */
    private String country;

    /**
     * Accuracy
     */
    private Integer accuracy;

    /**
     * GeoName ID
     */
    private Long geonameId;

    /**
     * Pleiades ID
     */
    private Long pleiadesId;

    /**
     * Osm ID
     */
    private Long osmId;

    /**
     * Creates new external catalog item from list of string containing information and catalog source type
     *
     * @param fieldList      list of string containing information about the catalog item
     * @param externalSource external source type
     */
    public ExternalCatalogItem(List<String> fieldList, ExternalSource externalSource) {
        this.externalSource = externalSource;
        if (externalSource == ExternalSource.PLEIADES) {
            this.locationPrecision = fieldList.get(8);
            this.maxDate = processIntField(fieldList.get(9));
            this.minDate = processIntField(fieldList.get(10));
            this.pid = fieldList.get(16);
            this.latitude = processDoubleField(fieldList.get(17));
            this.longitude = processDoubleField(fieldList.get(18));
            this.timePeriodKeys = fieldList.get(22);
            this.names.add(fieldList.get(24));
            this.names.addAll(processListField(fieldList.get(12)));
            this.names.addAll(processListField(fieldList.get(14)));
        } else if (externalSource == ExternalSource.GEONAMES) {
            this.geonameId = processLongField(fieldList.get(0));
            this.names.add(fieldList.get(1));
            this.names.add(fieldList.get(2));
            this.names.addAll(processListField(fieldList.get(3)));
            this.latitude = processDoubleField(fieldList.get(4));
            this.longitude = processDoubleField(fieldList.get(5));
            this.featureCode = fieldList.get(7);
            this.country = convertCountryCode(fieldList.get(8));
        } else if (externalSource == ExternalSource.CIGS) {
            this.accuracy = processIntField(fieldList.get(1));
            this.names.add(fieldList.get(3));
            this.names.add(fieldList.get(4));
            this.names.add(fieldList.get(5));
            this.names.add(fieldList.get(6));
            this.names.add(fieldList.get(7));
            this.names.add(fieldList.get(8));
            this.names.add(fieldList.get(9));
            this.names.add(fieldList.get(10));
            this.names.add(fieldList.get(11));
            this.pleiadesId = processLongField(fieldList.get(12));
            this.osmId = processLongField(fieldList.get(13));
            this.geonameId = processLongField(fieldList.get(15));
            this.longitude = processDoubleField(fieldList.get(23));
            this.latitude = processDoubleField(fieldList.get(24));
        }
    }

    /**
     * Converts country code to country name
     *
     * @param countryCode country code
     * @return country name
     */
    private String convertCountryCode(String countryCode) {
        if (COUNTRY_CODES.containsKey(countryCode)) {
            return COUNTRY_CODES.get(countryCode);
        }
        return countryCode;
    }

    /**
     * Processes field of type long
     *
     * @param field field
     * @return long if long found in field, null otherwise
     */
    private Long processLongField(String field) {
        Matcher matcher = INTEGER_PATTERN.matcher(field);
        if (matcher.find()) {
            return Long.parseLong(matcher.group());
        } else {
            return null;
        }
    }

    /**
     * Processes field of type int
     *
     * @param field field
     * @return int if int found in field, null otherwise
     */
    private Integer processIntField(String field) {
        Matcher matcher = INTEGER_PATTERN.matcher(field);
        if (matcher.find()) {
            return Integer.parseInt(matcher.group());
        } else {
            return null;
        }
    }

    /**
     * Processes field of type double
     *
     * @param field field
     * @return double if double found in field, null otherwise
     */
    private Double processDoubleField(String field) {
        Matcher matcher = DOUBLE_PATTERN.matcher(field);
        if (matcher.find()) {
            return Double.parseDouble(matcher.group());
        } else {
            return null;
        }
    }

    /**
     * Processes list field
     *
     * @param field list field (string seperated by commas)
     * @return set from list field
     */
    private Set<String> processListField(String field) {
        if (field.isEmpty()) {
            return new HashSet<>();
        }
        return Arrays.stream(field.split(",")).map(String::trim).filter(item -> !item.isEmpty()).collect(Collectors.toSet());
    }
}