Revize e21b7441

Added loading of external catalog items

re #9624

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

@@ -115 +115 @@
     )
     private Set<Type> types = new HashSet<>();
 
-    public CatalogItem(final List<String> csvFields) {
+    public CatalogItem(List<String> csvFields) {
 
         this.name = csvFields.get(1);
         Set<String> stringList = processListField(csvFields.get(2));

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

@@ -6 +6 @@
 import java.util.UUID;
 
 /**
- * Catalog service interface
+ * Catalog item service interface
  */
 public interface ICatalogItemService {
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalCatalogController.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * Controller for external catalog
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/external-catalog-items")
+public class ExternalCatalogController {
+
+    /**
+     * External catalog service
+     */
+    private final IExternalCatalogService externalCatalogService;
+
+    @PostMapping("")
+    public void updateCatalog() {
+        externalCatalogService.updateCatalog();
+    }
+}

backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalCatalogItem.java

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

backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalCatalogRepository.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.UUID;
+
+/**
+ * External catalog repository
+ */
+@Repository
+public interface ExternalCatalogRepository extends JpaRepository<ExternalCatalogItem, UUID> {
+}

backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalCatalogServiceImpl.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+import com.zaxxer.hikari.HikariDataSource;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.apache.tomcat.util.http.fileupload.FileUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.persistence.Table;
+import java.io.*;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+/**
+ * External catalog service implementation
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+@Slf4j
+public class ExternalCatalogServiceImpl implements IExternalCatalogService {
+    /**
+     * Buffer size
+     */
+    public static final int BUFFER_SIZE = 1024;
+    /**
+     * Directory where files for external directory will be stored
+     */
+    private static final String DIRECTORY_FOR_EXTERNAL_FILES = "sources";
+    /**
+     * URL for Pleiades file
+     */
+    private static final String PLEIADES_FILE_URL = "https://atlantides.org/downloads/pleiades/dumps/pleiades-names-latest.csv.gz";
+    /**
+     * Name of Pleiades file
+     */
+    private static final String PLEIADES_FILE_NAME = "pleiades-names-latest.csv";
+    /**
+     * URL for Pleiades file – needs to be formatted (more sources)
+     */
+    private static final String GEONAMES_FILE_URL = "https://download.geonames.org/export/dump/%s.zip";
+    /**
+     * Name of GeoNames file – needs to be formatted (more sources)
+     */
+    private static final String GEONAMES_FILE_NAME = "%s.txt";
+    /**
+     * URL for CIGS file
+     */
+    private static final String CIGS_FILE_URL = "https://zenodo.org/record/5642899/files/CIGS_v1_4_20211101.csv";
+    /**
+     * Name of CIGS file
+     */
+    private static final String CIGS_FILE_NAME = "CIGS_v1_4_20211101.csv";
+    /**
+     * Batch size for saving items
+     */
+    private static final int BATCH_SIZE = 5000;
+
+    /**
+     * External catalog repository
+     */
+    private final ExternalCatalogRepository externalCatalogRepository;
+
+    /**
+     * Hikari data source
+     */
+    private final HikariDataSource hikariDataSource;
+
+
+    @Override
+    public void updateCatalog() {
+        log.info("Updating external catalog");
+        try {
+            Files.createDirectories(Paths.get(DIRECTORY_FOR_EXTERNAL_FILES)); // creates directory if not exists
+            FileUtils.cleanDirectory(new File(DIRECTORY_FOR_EXTERNAL_FILES)); // cleans the directory
+            externalCatalogRepository.deleteAll(); // clears database – updated list will be stored later
+            addPleiadesSource();
+            addGeonamesSources();
+            addCigsSources();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        log.info("External catalog updated");
+    }
+
+    /**
+     * Downloads, extracts and reads Pleiades sources and saves them to database
+     */
+    private void addPleiadesSource() {
+        List<ExternalCatalogItem> externalCatalogItems = new ArrayList<>();
+        byte[] buffer = new byte[BUFFER_SIZE];
+        File pleiadesFile = new File(new File(DIRECTORY_FOR_EXTERNAL_FILES), PLEIADES_FILE_NAME);
+        try (InputStream fileIn = new URL(PLEIADES_FILE_URL).openStream();
+             GZIPInputStream gZIPInputStream = new GZIPInputStream(fileIn);
+             FileOutputStream fileOutputStream = new FileOutputStream(pleiadesFile)) {
+
+            int bytes_read;
+
+            while ((bytes_read = gZIPInputStream.read(buffer)) > 0) {
+                fileOutputStream.write(buffer, 0, bytes_read);
+            }
+
+            log.info("The Pleiades file was decompressed successfully");
+
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+
+        try (InputStream csvData = new FileInputStream(pleiadesFile)) {
+            CSVParser parser = CSVParser.parse(csvData, StandardCharsets.UTF_8, CSVFormat.Builder.create(CSVFormat.DEFAULT)
+                    .setHeader()
+                    .setSkipHeaderRecord(true)
+                    .build());
+            for (CSVRecord csvRecord : parser) {
+                externalCatalogItems.add(new ExternalCatalogItem(csvRecord.toList(), ExternalSource.PLEIADES));
+            }
+
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+        saveAllWithThreads(externalCatalogItems);
+    }
+
+    /**
+     * Downloads, extracts and reads GeoNames sources and saves them to database
+     */
+    private void addGeonamesSources() {
+        byte[] buffer = new byte[BUFFER_SIZE];
+        for (String countryCode : ExternalCatalogItem.COUNTRY_CODES.keySet()) {
+            List<ExternalCatalogItem> externalCatalogItems = new ArrayList<>();
+            // Downloads file from URL and extracts it
+            String url = String.format(GEONAMES_FILE_URL, countryCode);
+            try (ZipInputStream zis = new ZipInputStream(new URL(url).openStream())) {
+                ZipEntry zipEntry = zis.getNextEntry();
+                while (zipEntry != null) {
+                    FileOutputStream fileOutputStream = new FileOutputStream(new File(new File(DIRECTORY_FOR_EXTERNAL_FILES), zipEntry.getName()));
+                    int bytes_read;
+                    while ((bytes_read = zis.read(buffer)) > 0) {
+                        fileOutputStream.write(buffer, 0, bytes_read);
+                    }
+                    zipEntry = zis.getNextEntry();
+                    fileOutputStream.close();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            log.info("The Geonames file with country code " + countryCode + " was decompressed successfully");
+
+            // Reads file and adds catalog items to list
+            File geoNamesFile = new File(new File(DIRECTORY_FOR_EXTERNAL_FILES), String.format(GEONAMES_FILE_NAME, countryCode));
+            try (BufferedReader reader = new BufferedReader(new FileReader(geoNamesFile))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    externalCatalogItems.add(new ExternalCatalogItem(List.of(line.split("\t")), ExternalSource.GEONAMES));
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            saveAllWithThreads(externalCatalogItems);
+        }
+    }
+
+    /**
+     * Downloads and reads CIGS sources and saves them to database
+     */
+    private void addCigsSources() {
+        List<ExternalCatalogItem> externalCatalogItems = new ArrayList<>();
+        byte[] buffer = new byte[BUFFER_SIZE];
+        File cigsFile = new File(new File(DIRECTORY_FOR_EXTERNAL_FILES), CIGS_FILE_NAME);
+
+        try (InputStream inputStream = new URL(CIGS_FILE_URL).openStream();
+             FileOutputStream fileOutputStream = new FileOutputStream(cigsFile)) {
+            int bytes_read;
+
+            while ((bytes_read = inputStream.read(buffer)) > 0) {
+
+                fileOutputStream.write(buffer, 0, bytes_read);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        log.info("The CIGS file was downloaded successfully");
+
+        try (InputStream csvData = new FileInputStream(cigsFile)) {
+            CSVParser parser = CSVParser.parse(csvData, StandardCharsets.UTF_8, CSVFormat.Builder.create(CSVFormat.DEFAULT)
+                    .setHeader()
+                    .setSkipHeaderRecord(true)
+                    .build());
+            for (CSVRecord csvRecord : parser) {
+                externalCatalogItems.add(new ExternalCatalogItem(csvRecord.toList(), ExternalSource.CIGS));
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        saveAllWithThreads(externalCatalogItems);
+    }
+
+    /**
+     * Creates list of lists of external catalog items divided by batch size
+     *
+     * @param externalCatalogItems list of external catalog items
+     * @return divided list of lists of external catalog items
+     */
+    private List<List<ExternalCatalogItem>> createSublist(List<ExternalCatalogItem> externalCatalogItems) {
+        List<List<ExternalCatalogItem>> listOfSubList = new ArrayList<>();
+        for (int i = 0; i < externalCatalogItems.size(); i += BATCH_SIZE) {
+            if (i + BATCH_SIZE <= externalCatalogItems.size()) {
+                listOfSubList.add(externalCatalogItems.subList(i, i + BATCH_SIZE));
+            } else {
+                listOfSubList.add(externalCatalogItems.subList(i, externalCatalogItems.size()));
+            }
+        }
+        return listOfSubList;
+    }
+
+    /**
+     * Divides list of external catalog items to sublist, creates threads (for saving sublists in batch) and executes them
+     *
+     * @param externalCatalogItems list of external catalog items
+     */
+    private void saveAllWithThreads(List<ExternalCatalogItem> externalCatalogItems) {
+        ExecutorService executorService = Executors.newFixedThreadPool(hikariDataSource.getMaximumPoolSize());
+        List<List<ExternalCatalogItem>> subList = createSublist(externalCatalogItems);
+        List<Callable<Void>> callables = subList.stream().map(sublist ->
+                (Callable<Void>) () -> {
+                    saveAllInBatch(sublist);
+                    return null;
+                }).collect(Collectors.toList());
+        try {
+            executorService.invokeAll(callables);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Saves external catalog items in batch
+     *
+     * @param externalCatalogItems list of external catalog items
+     */
+    private void saveAllInBatch(List<ExternalCatalogItem> externalCatalogItems) {
+        String sql = String.format("INSERT INTO %s (id, external_source, latitude, longitude, location_precision, max_date, " +
+                "min_date, time_period_keys, pid, names, feature_code, country, accuracy, geoname_id, pleiades_id, osm_id) " +
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", ExternalCatalogItem.class.getAnnotation(Table.class).name());
+        try (Connection connection = hikariDataSource.getConnection();
+             PreparedStatement statement = connection.prepareStatement(sql)) {
+            int counter = 0;
+            for (ExternalCatalogItem item : externalCatalogItems) {
+                statement.clearParameters();
+                statement.setObject(1, item.getId());
+                statement.setString(2, item.getExternalSource().name());
+                statement.setObject(3, item.getLatitude());
+                statement.setObject(4, item.getLongitude());
+                statement.setString(5, item.getLocationPrecision());
+                statement.setObject(6, item.getMaxDate());
+                statement.setObject(7, item.getMinDate());
+                statement.setString(8, item.getTimePeriodKeys());
+                statement.setString(9, item.getPid());
+                statement.setString(10, String.join(",", item.getNames()));
+                statement.setString(11, item.getFeatureCode());
+                statement.setString(12, item.getCountry());
+                statement.setObject(13, item.getAccuracy());
+                statement.setObject(14, item.getGeonameId());
+                statement.setObject(15, item.getPleiadesId());
+                statement.setObject(16, item.getOsmId());
+                statement.addBatch();
+                counter++;
+                if (counter % BATCH_SIZE == 0 || counter == externalCatalogItems.size()) {
+                    statement.executeBatch();
+                    statement.clearBatch();
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

backend/src/main/java/cz/zcu/kiv/backendapi/external/ExternalSource.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+/**
+ * Enum representing different sources of external catalog items
+ */
+public enum ExternalSource {
+    PLEIADES,
+    GEONAMES,
+    CIGS
+}

backend/src/main/java/cz/zcu/kiv/backendapi/external/IExternalCatalogService.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+/**
+ * External catalog service interface
+ */
+public interface IExternalCatalogService {
+    /**
+     * Updates external catalog
+     */
+    void updateCatalog();
+}

backend/src/main/java/cz/zcu/kiv/backendapi/external/SetToStringConverter.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.external;
+
+import javax.persistence.AttributeConverter;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Class that converts set of strings to string and string to set of strings
+ */
+public class SetToStringConverter implements AttributeConverter<Set<String>, String> {
+    /**
+     * Delimiter for splitting/joining string
+     */
+    private static final String DELIMITER = ",";
+
+    @Override
+    public String convertToDatabaseColumn(Set<String> attribute) {
+        return attribute == null ? null : String.join(DELIMITER, attribute);
+    }
+
+    @Override
+    public Set<String> convertToEntityAttribute(String dbData) {
+        return dbData == null ? new HashSet<>() : Arrays.stream(dbData.split(DELIMITER)).collect(Collectors.toSet());
+    }
+
+}

backend/src/main/java/cz/zcu/kiv/backendapi/security/SecurityConfig.java

@@ -62 +62 @@
         PERMITTED_ENDPOINTS.put("/v3/api-docs/swagger-config", HttpMethod.GET);
         PERMITTED_ENDPOINTS.put("/catalog-items", HttpMethod.GET);
         PERMITTED_ENDPOINTS.put("/catalog-items/**", HttpMethod.GET);
+        PERMITTED_ENDPOINTS.put("/external-catalog-items", HttpMethod.POST); //TODO delete
     }
 
     /**
@@ -83 +84 @@
                 .authorizeRequests()
                 .antMatchers(HttpMethod.GET, PERMITTED_ENDPOINTS.keySet().stream().filter(k -> PERMITTED_ENDPOINTS.get(k).equals(HttpMethod.GET)).toArray(String[]::new)).permitAll()
                 .antMatchers(HttpMethod.POST, "/login").permitAll()
+                .antMatchers(HttpMethod.POST, "/external-catalog-items").permitAll() //TODO delete
                 .antMatchers(HttpMethod.PATCH, "/users/*/permissions", "/users/*/password").hasRole(Role.ADMIN.name())
                 .antMatchers(HttpMethod.DELETE, "/users/**").hasRole(Role.ADMIN.name())
                 .antMatchers(HttpMethod.GET, "/users").hasRole(Role.ADMIN.name())