D-Net

FROM tomcat:7.0.90-jre8

MAINTAINER "pkanakakis@di.uoa.gr"

RUN ["rm", "-fr", "/usr/local/tomcat/webapps/ROOT"]

COPY ./target/uoa-repository-manager-service.war /usr/local/tomcat/webapps/uoa-repository-manager-service.war

COPY src/main/resources/dnet-override-new.properties /usr/local/tomcat/lib/dnet-override.properties

#COPY src/main/resources/application.properties /usr/local/tomcat/lib/application.properties

#COPY src/main/resources/email-texts.properties /usr/local/tomcat/lib/email-texts.properties

VOLUME /var/log/uoa-repository-manager-service:/var/log/uoa-repository-manager-service/

CMD ["catalina.sh", "run"]

/*

package unitest;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.dnetlib.repo.manager.config.RepoManagerContextLoaderListener;

import org.apache.commons.lang.StringEscapeUtils;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.net.URL;

import java.net.URLEncoder;

import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = RepoManagerContextLoaderListener.class)

public class PiwikTest {

    String analyticsURL = "https://analytics.openaire.eu/addsite.php?";

    @Test

    public void enableMetricsRepo1(){

        String officialName = "BỘ SƯU TẬP SỐ";

        String repoWebsite = "http://www.vnulib.edu.vn:8000/dspace/";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    @Test

    public void enableMetricsRepo2(){

        String officialName = "ILC4CLARIN repository of language resources and tools";

        String repoWebsite = "https://dspace-clarin-it.ilc.cnr.it/repository/xmlui";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    @Test

    public void enableMetricsRepo3(){

        String officialName = "ANSTO Publications Online";

        String repoWebsite = "http://apo.ansto.gov.au/dspace/";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    private void enableMetrics(String officialName, String repoWebsite, String analyticsURL) {

        String url;

        try {

            url = analyticsURL + "siteName=" + URLEncoder.encode(officialName, "UTF-8") + "&url="

                    + URLEncoder.encode(repoWebsite, "UTF-8");

            url = StringEscapeUtils.escapeJava(url);

            Map map = null;

            String siteId = null;

            URL u = new URL(url);

            map = new ObjectMapper().readValue(u, Map.class);

            if(map.get("value")!=null) {

                siteId = map.get("value").toString();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}*/

//package unitest;

//

//import eu.dnetlib.repo.manager.config.RepoManagerContextLoaderListener;

//import eu.dnetlib.repo.manager.utils.OaiTools;

//import org.junit.Test;

//import org.junit.runner.RunWith;

//import org.springframework.test.context.ContextConfiguration;

//import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//

//@RunWith(SpringJUnit4ClassRunner.class)

//@ContextConfiguration(classes = RepoManagerContextLoaderListener.class)

////@WebAppConfiguration

//public class ValidatorTest {

//

//

//    @Test

//    public void identiFy(){

//

//        String url = "https://repozitorij.srce.unizg.hr/oai";

//

//

//        System.out.println("Identify repository with url : " + url);

//        try {

//            System.out.println(OaiTools.identifyRepository(url));

//        } catch (Exception e) {

//            System.out.println(e);

//        }

//    }

//

//

//}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

               http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:annotation-config/>

    <context:component-scan base-package="eu.dnetlib.repo.manager.service.*"/>

    <tx:annotation-driven transaction-manager="txManager"/>

    <bean class="eu.dnetlib.repo.manager.config.CascadingPropertyLoader"

          id="propertyLoader">

        <property name="order" value="2"/>

        <property name="properties">

            <bean class="eu.dnetlib.conf.WebappContextProperyFactory">

                <property name="propertyFetcher">

                    <bean class="eu.dnetlib.conf.PropertyFetcher"/>

                </property>

            </bean>

        </property>

        <property name="ignoreUnresolvablePlaceholders" value="true"/>

        <property name="locations">

            <list>

                <value>classpath*:/gr/**/springContext-*.properties</value>

                <value>classpath*:/eu/**/springContext-*.properties</value>

                <value>classpath*:/application.properties</value>

                <value>classpath*:/email-texts.properties</value>

                <value>classpath*:dnet-site-wizard.properties</value>

                <value>classpath*:dnet-site-override.properties</value>

                <value>classpath*:dnet-wizard.properties</value>

                <value>classpath*:dnet-override-new.properties</value>

                <value>classpath*:dnet-validator-wizard.properties</value>

                <value>classpath*:dnet-validator-override.properties</value>

                <value>classpath*:dnet-site-force-override.properties</value>

                <value>classpath*:dnet-force-override.properties</value>

            </list>

        </property>

    </bean>

    <bean id="repomanager.dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${repomanager.db.driverClassName}" />

        <property name="url" value="${repomanager.db.url}" />

        <property name="username" value="${repomanager.db.username}" />

        <property name="password" value="${repomanager.db.password}" />

        <property name="maxIdle" value="10" />

        <property name="maxActive" value="100" />

        <property name="maxWait" value="10000" />

        <property name="validationQuery" value="SELECT 1;" />

        <property name="testOnBorrow" value="true" />

        <property name="testOnReturn" value="true" />

        <property name="testWhileIdle" value="true" />

        <property name="timeBetweenEvictionRunsMillis" value="1200000" />

        <property name="minEvictableIdleTimeMillis" value="1800000" />

        <property name="numTestsPerEvictionRun" value="5" />

        <property name="poolPreparedStatements" value="true" />

        <property name="defaultAutoCommit" value="true" />

    </bean>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="repomanager.dataSource"/>

    </bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <import resource="classpath*:/application-context.xml"/>

    <import resource="classpath*:/eu/dnetlib/soap/cxf/applicationContext-eprbuilders.xml"/>

    <import resource="classpath*:/eu/dnetlib/clients/ws/springContext-locatorFactory.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/util/springContext-locators.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-lookupFactory.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-lookupClients.xml"/>

    <import resource="classpath*:/eu/dnetlib/enabling/hcm/springContext-hcmService.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-commons.xml"/>

    <!--<import resource="classpath*:/gr/uoa/di/driver/app/springContext-registrator.xml"/>-->

    <bean id="maillib" class="eu.dnetlib.utils.MailLibrary" init-method="init">

        <property name="mailhost" value="${services.validator.mail.host}"/>

        <property name="smtpPort" value="${services.validator.mail.port}"/>

        <property name="authenticate" value="${services.validator.mail.authenticate}"/>

        <property name="username" value="${services.validator.mail.username}"/>

        <property name="password" value="${services.validator.mail.password}"/>

        <property name="from" value="${services.validator.mail.fromAddress}"/>

        <property name="replyTo" value="${services.validator.mail.replyToAddress}"/>

        <property name="mode" value="${services.validator.mail.mode}"/>

        <property name="debug" value="${services.validator.mail.debug}"/>

    </bean>

    <bean class="eu.dnetlib.repo.manager.config.CascadingPropertyLoader"

          id="propertyLoader">

        <property name="order" value="2"/>

        <property name="properties">

            <bean class="eu.dnetlib.conf.WebappContextProperyFactory">

                <property name="propertyFetcher">

                    <bean class="eu.dnetlib.conf.PropertyFetcher"/>

                </property>

            </bean>

        </property>

        <property name="ignoreUnresolvablePlaceholders" value="true"/>

        <property name="locations">

            <list>

                <value>classpath*:/gr/**/springContext-*.properties</value>

                <value>classpath*:/eu/**/springContext-*.properties</value>

                <value>classpath*:/application.properties</value>

                <value>classpath*:/email-texts.properties</value>

                <value>classpath*:dnet-site-wizard.properties</value>

                <value>classpath*:dnet-site-override.properties</value>

                <value>classpath*:dnet-wizard.properties</value>

                <value>classpath*:dnet-override-new.properties</value>

                <value>classpath*:dnet-validator-wizard.properties</value>

                <value>classpath*:dnet-validator-override.properties</value>

                <value>classpath*:dnet-site-force-override.properties</value>

                <value>classpath*:dnet-force-override.properties</value>

            </list>

        </property>

    </bean>

    <bean id="repomanager.dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${repomanager.db.driverClassName}" />

        <property name="url" value="${repomanager.db.url}" />

        <property name="username" value="${repomanager.db.username}" />

        <property name="password" value="${repomanager.db.password}" />

        <property name="maxIdle" value="10" />

        <property name="maxActive" value="100" />

        <property name="maxWait" value="10000" />

        <property name="validationQuery" value="SELECT 1;" />

        <property name="testOnBorrow" value="true" />

        <property name="testOnReturn" value="true" />

        <property name="testWhileIdle" value="true" />

        <property name="timeBetweenEvictionRunsMillis" value="1200000" />

        <property name="minEvictableIdleTimeMillis" value="1800000" />

        <property name="numTestsPerEvictionRun" value="5" />

        <property name="poolPreparedStatements" value="true" />

        <property name="defaultAutoCommit" value="true" />

    </bean>

    <tx:annotation-driven transaction-manager="txManager"/>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="repomanager.dataSource"/>

    </bean>

    <mvc:resources mapping="swagger-ui.html" location="classpath:/META-INF/resources/"/>

    <mvc:resources mapping="/webjars/**" location="classpath:/META-INF/resources/webjars/"/>

    <bean class="eu.dnetlib.repo.manager.config.SwaggerConfig"/>

</beans>

package eu.dnetlib.repo.manager.service;

import org.springframework.http.ResponseEntity;

public interface UserService {

    ResponseEntity<Object> login();

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.repo.manager.domain.RepositorySnippet;

import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;

import eu.dnetlib.repo.manager.shared.*;

import org.json.JSONException;

import org.springframework.security.core.Authentication;

import java.io.IOException;

import java.util.List;

import java.util.Map;

public interface RepositoryService {

    Country[] getCountries() ;

    List<RepositorySnippet> getRepositoriesByCountry(String country, String mode, Boolean managed) throws JSONException, IOException;

    List<Repository> getRepositoriesOfUser(String userEmail,

                                           String page,

                                           String size) throws JSONException;

    Repository getRepositoryById(String id) throws JSONException, ResourceNotFoundException;

    List<AggregationDetails> getRepositoryAggregations(String id) throws JSONException;

    Map<String,List<AggregationDetails>> getRepositoryAggregationsByYear(String id) throws JSONException;

    List<Repository> getRepositoriesByName(String name,

                                           String page,

                                           String size) throws JSONException;

    List<RepositoryInterface> getRepositoryInterface(String id) throws JSONException;

    Repository addRepository(String datatype, Repository repository) throws Exception;

    void deleteRepositoryInterface(String id, String registeredBy);

    RepositoryInterface addRepositoryInterface(String datatype,

                                               String repoId,

                                               String registeredBy,

                                               RepositoryInterface iFace) throws JSONException,ResourceNotFoundException;

    List<String> getDnetCountries();

    List<String> getTypologies();

    List<Timezone> getTimezones();

    Repository updateRepository(Repository repository, Authentication authentication) throws Exception;

    List<String> getUrlsOfUserRepos(String user_email,

                                    String page,

                                    String size) throws JSONException;

    List<String> getDatasourceVocabularies(String mode);

    Map<String, String> getCompatibilityClasses(String mode);

    Map<String, String> getDatasourceClasses(String mode);

    String getCountryName(String countryCode);

    MetricsInfo getMetricsInfoForRepository(String repoId) throws RepositoryServiceException;

    Map<String, String> getListLatestUpdate(String mode) throws RepositoryServiceException, JSONException;

    RepositoryInterface updateRepositoryInterface(String repositoryId, String registeredBy, RepositoryInterface repositoryInterface) throws Exception;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.service.customHystrixCommands.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;

import org.springframework.web.client.RestTemplate;

import java.util.HashMap;

import java.util.Map;

@Service("statsService")

public class StatsServiceImpl implements StatsService {

    @Autowired

    RestTemplate restTemplate;

    @Value("${search.api.baseAddress}")

    private String baseAddress;

    @Value("${search.api.usagestats}")

    private String usagestatsBaseAddress;

    @Value("${search.api.usageEvents}")

    private String usagestatsEvents;

    @Override

    public Map getStatistics()  {

        UsageStatsTotalHystrixCommand usageStatsTotalHystrixCommand = new UsageStatsTotalHystrixCommand(usagestatsEvents,restTemplate);

        DataRepositoriesHystrixCommand dataRepositoriesHystrixCommand = new DataRepositoriesHystrixCommand(baseAddress,restTemplate);

        AggregatorsHystrixCommand aggregatorsHystrixCommand = new AggregatorsHystrixCommand(baseAddress,restTemplate);

        LiteratureHystrixCommand literatureHystrixCommand = new LiteratureHystrixCommand(baseAddress,restTemplate);

        JournalHystrixCommand journalHystrixCommand = new JournalHystrixCommand(baseAddress,restTemplate);

        PublicationHystrixCommand publicationHystrixCommand = new PublicationHystrixCommand(baseAddress,restTemplate);

        DatasetsHystrixCommand datasetsHystrixCommand = new DatasetsHystrixCommand(baseAddress,restTemplate);

        SoftwareHystrixCommand softwareHystrixCommand = new SoftwareHystrixCommand(baseAddress,restTemplate);

        LastYearUsageStatsHystrixCommand lastYearUsageStatsHystrixCommand = new LastYearUsageStatsHystrixCommand(usagestatsBaseAddress,restTemplate);

        Map<String,Object> stats = new HashMap<>();

        stats.put("aggregators",aggregatorsHystrixCommand.execute());

        stats.put("dataRepositories",dataRepositoriesHystrixCommand.execute());

        stats.put("literature",literatureHystrixCommand.execute());

        stats.put("journal",journalHystrixCommand.execute());

        stats.put("publications",publicationHystrixCommand.execute());

        stats.put("datasets",datasetsHystrixCommand.execute());

        stats.put("software",softwareHystrixCommand.execute());

        stats.put("lastYearUsagestats", lastYearUsageStatsHystrixCommand.execute());

        stats.put("usagestats",usageStatsTotalHystrixCommand.execute());

        return stats;

    }

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.PiwikInfo;

import eu.dnetlib.repo.manager.shared.RepositoryServiceException;

import org.springframework.http.ResponseEntity;

import java.util.List;

public interface PiWikService {

    PiwikInfo getPiwikSiteForRepo(String repositoryId);

    PiwikInfo savePiwikInfo(PiwikInfo piwikInfo);

    List<PiwikInfo> getPiwikSitesForRepos();

    ResponseEntity<Object> approvePiwikSite(String repositoryId);

    String getOpenaireId(String repositoryid);

    ResponseEntity<Object> markPiwikSiteAsValidated(String repositoryId) throws RepositoryServiceException;

    PiwikInfo enableMetricsForRepository(String officialName, String repoWebsite, PiwikInfo piwikInfo) throws RepositoryServiceException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.shared.BrokerException;

import eu.dnetlib.repo.manager.shared.Term;

import eu.dnetlib.repo.manager.shared.broker.*;

import io.swagger.annotations.Api;

import org.json.JSONException;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

import java.util.List;

import java.util.Map;

public interface BrokerService {

    DatasourcesBroker getDatasourcesOfUser(String user, String includeShared, String includeByOthers) throws BrokerException, JSONException;

    List<BrowseEntry> getTopicsForDatasource(String datasourceName) throws BrokerException;

    EventsPage advancedShowEvents(String page,

                                  String size,

                                  AdvQueryObject advQueryObject) throws BrokerException, JSONException ,IOException;

    EventsPage showEvents(String datasourceName,

                          String topic,

                          String page,

                          String size) throws BrokerException, JSONException;

    Map<String, List<SimpleSubscriptionDesc>> getSimpleSubscriptionsOfUser(String userEmail) throws BrokerException;

    Subscription subscribe(OpenaireSubscription obj) throws BrokerException;

    ResponseEntity<Object> unsubscribe(String subscriptionId) throws BrokerException;

    Subscription getSubscription(String subscriptionId) throws BrokerException;

    Map<String, Term> getDnetTopics() throws BrokerException;

    EventsPage getNotificationsBySubscriptionId(String subscriptionId, String page, String size) throws BrokerException;

    Map<String, List<Subscription>> getSubscriptionsOfUser(String userEmail) throws BrokerException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.api.functionality.ValidatorServiceException;

import eu.dnetlib.domain.functionality.validator.JobForValidation;

import eu.dnetlib.domain.functionality.validator.RuleSet;

import eu.dnetlib.domain.functionality.validator.StoredJob;

import eu.dnetlib.repo.manager.shared.InterfaceInformation;

import eu.dnetlib.repo.manager.shared.ValidationServiceException;

import org.json.JSONException;

import org.springframework.http.ResponseEntity;

import java.util.List;

public interface ValidatorService {

    JobForValidation submitJobForValidation(JobForValidation jobForValidation) throws ValidatorServiceException;

    ResponseEntity<Object> reSubmitJobForValidation(String email, String jobId) throws JSONException, ValidatorServiceException;

    List<RuleSet> getRuleSets(String mode);

    List<String> getSetsOfRepository(String url);

    boolean identifyRepo(String url);

    RuleSet getRuleSet(String acronym);

    List<StoredJob> getStoredJobsNew(String user,

                                     String jobType,

                                     String offset,

                                     String limit,

                                     String dateFrom,

                                     String dateTo,

                                     String validationStatus) throws ValidatorServiceException;

    int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws ValidatorServiceException;

    InterfaceInformation getInterfaceInformation(String baseUrl) throws ValidationServiceException;

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class AggregatorsHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    String baseAddress;

    public AggregatorsHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress + "/resources" +

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository Aggregator " +

                "     or datasourcetypename exact Publication Repository Aggregator )";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class UsageStatsTotalHystrixCommand extends HystrixCommand<Integer> {

    RestTemplate restTemplate ;

    String usagestatsEvents;

    public UsageStatsTotalHystrixCommand(String usagestatsEvents,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.usagestatsEvents = usagestatsEvents;

        this.restTemplate = restTemplate;

    }

    @Override

    protected Integer run() {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsEvents)

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        Map metadata = (Map) ((Map)rs.getBody()).get("totals");

//        String rs = restTemplate.getForObject(uriComponents.toUri(), String.class);

//        JSONObject resultSet = new JSONObject(rs);

//        JSONObject totals = resultSet.getJSONObject("totals");

        return (Integer) metadata.get("events");

    }

    @Override

    protected Integer getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class DatasetsHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    String baseAddress;

    public DatasetsHystrixCommand(String baseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.restTemplate = restTemplate;

        this.baseAddress = baseAddress;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/datasets/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class LastYearUsageStatsHystrixCommand extends HystrixCommand<Map> {

    RestTemplate restTemplate;

    String usagestatsBaseAddress;

    public LastYearUsageStatsHystrixCommand(String usagestatsBaseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.usagestatsBaseAddress = usagestatsBaseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected Map run() throws Exception {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsBaseAddress + "/totals")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        List yearly_stats = (List) ((Map)rs.getBody()).get("yearly_stats");

        Map lastYear = (Map) yearly_stats.get(yearly_stats.size()-1);

        Integer downloads = (Integer) lastYear.get("downloads");

        Integer views = (Integer) lastYear.get("views");

        Integer year = (Integer) lastYear.get("year");

        Map<String,Object> usagestats = new HashMap<>();

        usagestats.put("number",String.valueOf(downloads+views));

        usagestats.put("year",year);

        return usagestats;

    }

    @Override

    protected Map getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class PublicationHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public PublicationHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress + "/publications/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class JournalHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public JournalHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/resources"+

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Journal";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class SoftwareHystrixCommand extends HystrixCommand<String> {

    String baseAddress;

    RestTemplate restTemplate;

    public SoftwareHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() {

        String url = baseAddress + "/software/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class LiteratureHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public LiteratureHystrixCommand(String baseAddress , RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/resources"+

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository  " +

                "     or datasourcetypename exact Publication Repository )";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service.customHystrixCommands;

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class DataRepositoriesHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate ;

    private String baseAddress;

    public DataRepositoriesHystrixCommand(String baseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() {

        String url = baseAddress+"/resources" +

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Data Repository ";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page",0)

                .queryParam("size",0)

                .queryParam("format","json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        Map metadata = (Map) ((Map)rs.getBody()).get("meta");

        return String.valueOf(metadata.get("total"));

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.api.functionality.ValidatorServiceException;

import eu.dnetlib.domain.functionality.validator.StoredJob;

import eu.dnetlib.repo.manager.shared.JobsOfUser;

import io.swagger.annotations.Api;

import org.json.JSONException;

import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.*;

public interface MonitorService {

    JobsOfUser getJobsOfUser(String user,

                             String jobType,

                             String offset,

                             String limit,

                             String dateFrom,

                             String dateTo,

                             String validationStatus,

                             String includeJobsTotal) throws JSONException, ValidatorServiceException;

    int getJobsOfUserPerValidationStatus(String user,

                                         String jobType,

                                         String validationStatus) throws JSONException;

    StoredJob getJobSummary(String jobId,

                            String groupBy) throws JSONException;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.domain.data.PiwikInfo;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.functionality.validator.JobForValidation;

import org.springframework.security.core.Authentication;

public interface EmailUtils {

    void reportException(Exception exception);

    void sendAdministratorRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendUserRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendAdministratorMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendUserMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendUserRegistrationEmail(Repository repository, Authentication authentication) throws Exception;

    void sendUserUpdateRepositoryEmail(Repository repository, Authentication authentication) throws Exception;

    void sendSubmitJobForValidationEmail(Authentication authentication, JobForValidation jobForValidation) throws Exception;

}

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.usagestats.sushilite.domain.ReportItem;

import eu.dnetlib.usagestats.sushilite.domain.ReportResponseWrapper;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.core.ParameterizedTypeReference;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import org.springframework.security.access.prepost.PreAuthorize;

import org.springframework.stereotype.Service;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.client.RestClientException;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.ArrayList;

import java.util.List;

@Service("sushiliteService")

public class SushiliteServiceImpl implements SushiliteService {

    @Value("${services.repomanager.usagestats.sushiliteEndpoint}")

    private String usagestatsSushiliteEndpoint;

    @Autowired

    private EmailUtils emailUtils;

    private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger.getLogger(SushiliteServiceImpl.class);

    @Override

    @PreAuthorize("hasRole('ROLE_USER')")

    public ReportResponseWrapper getReportResults(@PathVariable("page") String page,

                                                  @PathVariable("pageSize") String pageSize,

                                                  @RequestParam(value = "Report") String Report,

                                                  @RequestParam(value = "Release",defaultValue="4") String Release,

                                                  @RequestParam(value = "RequestorID",required=false,defaultValue="anonymous") String RequestorID,

                                                  @RequestParam(value = "BeginDate",required=false,defaultValue="") String BeginDate,

                                                  @RequestParam(value = "EndDate",required=false,defaultValue="") String EndDate,

                                                  @RequestParam(value = "RepositoryIdentifier") String RepositoryIdentifier,

                                                  @RequestParam(value = "ItemIdentifier",required=false,defaultValue="") String ItemIdentifier,

                                                  @RequestParam(value = "ItemDataType",required=false,defaultValue="") String ItemDataType,

                                                  @RequestParam(value = "Granularity") String Granularity,

                                                  @RequestParam(value = "Pretty",required=false,defaultValue="") String Pretty) {

            //build the uri params

            UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(this.usagestatsSushiliteEndpoint + "GetReport/")

                                                                .queryParam("Report", Report)

                                                                .queryParam("Release", Release)

                                                                .queryParam("RequestorID", RequestorID)

                                                                .queryParam("BeginDate", BeginDate)

                                                                .queryParam("EndDate", EndDate)

                                                                .queryParam("RepositoryIdentifier", RepositoryIdentifier)

                                                                .queryParam("ItemIdentifier", ItemIdentifier)

                                                                .queryParam("ItemDataType", ItemDataType)

                                                                .queryParam("Granularity", Granularity)

                                                                .queryParam("Pretty", Pretty);

            //create new template engine

            RestTemplate template = new RestTemplate();

            template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());

            ResponseEntity<ReportResponseWrapper> resp;

            try {

                //communicate with endpoint

                resp = template.exchange(

                        builder.build().encode().toUri(),

                        HttpMethod.GET,

                        null,

                        new ParameterizedTypeReference<ReportResponseWrapper>() {

                        });

            } catch (RestClientException e) {

                LOGGER.debug("Exception on getReportResults" , e);

                emailUtils.reportException(e);

                throw e;

            }

            // check remote api's response

            System.out.println("sushi responded status " + resp.getStatusCode());

            // get the items corresponding to the requested page

            List<ReportItem> requestedItemList = new ArrayList<>();

            if (resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems() != null) {

                try {

                    int totalItems = resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems().size();

                    int size = Integer.parseInt(pageSize);

                    int offset = Integer.parseInt(page)*size;

                    if (offset < totalItems ) {

                        int upperIndex = offset+size;

                        if (upperIndex > totalItems) {

                            upperIndex = totalItems;

                        }

                        requestedItemList = resp.getBody().getReportResponse().getReportWrapper().getReport().getCustomer().getReportItems().subList(offset,upperIndex);

                    }

                } catch (NumberFormatException e) {

                    LOGGER.debug("Exception on getReportResults - trying to cast strings to integers", e);

                    //emailUtils.reportException(e);

                    throw e;

                }

            }

            ReportResponseWrapper newReportResponse = resp.getBody();

            newReportResponse.getReportResponse().getReportWrapper().getReport().getCustomer().setReportItems(requestedItemList);

            return newReportResponse;

    }

}

package eu.dnetlib.repo.manager.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

import eu.dnetlib.repo.manager.exception.EndPointException;

import org.json.JSONException;

import java.util.Map;

public interface StatsService {

    Map getStatistics() ;

}

package eu.dnetlib.repo.manager.service;

import org.mitre.openid.connect.model.OIDCAuthenticationToken;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Service("userService")

public class UserServiceImpl implements UserService {

    private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger

            .getLogger(UserServiceImpl.class);

    @Value("${oidc.issuer}")

    private String oidc_issuer;

    @Override

    public ResponseEntity<Object> login() {

        OIDCAuthenticationToken authentication = (OIDCAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();

        LOGGER.debug("User authentication : " + authentication);

        Map<String,Object> body = new HashMap<>();

        body.put("sub",authentication.getSub());

        if(authentication.getUserInfo().getName() == null || authentication.getUserInfo().getName().equals(""))

            body.put("name",authentication.getUserInfo().getGivenName() + " " + authentication.getUserInfo().getFamilyName());

        else

            body.put("name",authentication.getUserInfo().getName());

        body.put("email",authentication.getUserInfo().getEmail());

        List<String> roles = authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());

        body.put("role",roles);

        return new ResponseEntity<>(body, HttpStatus.OK);

    }

}

package eu.dnetlib.repo.manager.service;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.SerializationFeature;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.domain.enabling.Vocabulary;

import eu.dnetlib.repo.manager.domain.RepositorySnippet;

import eu.dnetlib.repo.manager.domain.RequestFilter;

import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;

import eu.dnetlib.repo.manager.shared.*;

import eu.dnetlib.repo.manager.utils.Converter;

import gr.uoa.di.driver.enabling.vocabulary.VocabularyLoader;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.core.ParameterizedTypeReference;

import org.springframework.http.*;

import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Service;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.client.RestClientException;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import javax.annotation.PostConstruct;

import java.io.IOException;

import java.sql.Timestamp;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.stream.Collectors;

@Service("repositoryService")

public class RepositoryServiceImpl implements RepositoryService {

    @Value("${api.baseAddress}")

    private String baseAddress;

    @Autowired

    RestTemplate restTemplate;

    private HttpHeaders httpHeaders;

    private final String[] vocabularyNames = {"dnet:countries", "dnet:datasource_typologies", "dnet:compatibilityLevel"};

    private static final Logger LOGGER = Logger.getLogger(RepositoryServiceImpl.class);

    @Value("${services.repomanager.usageStatisticsDiagramsBaseURL}")

    private String usageStatisticsDiagramsBaseURL;

    @Value("${services.repomanager.usageStatisticsNumbersBaseURL}")

    private String usageStatisticsNumbersBaseURL;

    @Autowired

    private VocabularyLoader vocabularyLoader;

    @Autowired

    private PiWikService piWikService;

    @Autowired

    private EmailUtils emailUtils;

    private Map<String, Vocabulary> vocabularyMap = new ConcurrentHashMap<String, Vocabulary>();

    private Map<String, String> countriesMap = new HashMap<>();

    private Map<String, String> inverseCountriesMap = new HashMap<>();

    private static Map<String,List<String>> dataSourceClass = new HashMap<String,List<String>>(){{

        put("opendoar",new ArrayList<String>(){{ add("pubsrepository::institutional");

                                                    add("pubsrepository::thematic");

                                                    add("pubsrepository::unknown");

                                                    add("pubsrepository::mock");

        }});

        put("re3data",new ArrayList<String>(){{ add("datarepository::unknown");

        }});

        put("journal",new ArrayList<String>(){{ add("pubsrepository::journal");

        }});

        put("aggregator",new ArrayList<String>(){{ add("aggregator::pubsrepository::institutional");

                                                        add("aggregator::pubsrepository::journals");

                                                        add("aggregator::datarepository");

                                                        add("aggregator::pubsrepository::unknown");

        }});

    }};

    private static Map<String,String> invertedDataSourceClass = new HashMap<String,String>(){{

        put("pubsrepository::institutional","opendoar");

        put("pubsrepository::thematic","opendoar");

        put("pubsrepository::unknown","opendoar");

        put("pubsrepository::mock","opendoar");

        put("datarepository::unknown","re3data");

        put("pubsrepository::journal","journal");

        put("aggregator::pubsrepository::institutional","aggregator");

        put("aggregator::pubsrepository::journals","aggregator");

        put("aggregator::datarepository","aggregator");

        put("aggregator::pubsrepository::unknown","aggregator");

    }};

    @PostConstruct

    private void init() {

        LOGGER.debug("Initialization method of repository api!");

        LOGGER.debug("Updated version!");

        httpHeaders = new HttpHeaders();

        httpHeaders.set("Content-Type", "application/json");

        for (String vocName : vocabularyNames) {

            vocabularyMap.put(vocName, vocabularyLoader.getVocabulary(vocName, Locale.ENGLISH, Locale.ROOT));

        }

        Country[] countries = getCountries();

        for (Country c : countries) {

            countriesMap.put(c.getName(), c.getCode());

            inverseCountriesMap.put(c.getCode(), c.getName());

        }

    }

    @Override

    public Country[] getCountries() {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(baseAddress + "/ds/countries")

                .build().encode();

        return restTemplate.getForObject(uriComponents.toUri(), Country[].class);

    }

    @Override

    public List<RepositorySnippet> getRepositoriesByCountry(@PathVariable("country") String country,

                                                            @PathVariable("mode") String mode,

                                                            @RequestParam(value = "managed",required=false) Boolean managed) throws JSONException, IOException {

        LOGGER.debug("Getting repositories by country!");

        int page = 0;

        int size = 100;

        List<RepositorySnippet> resultSet = new ArrayList<>();

        ObjectMapper mapper = new ObjectMapper();

        String filterKey = "UNKNOWN";

        if (mode.equalsIgnoreCase("opendoar"))

            filterKey = "openaire____::opendoar";

        else if (mode.equalsIgnoreCase("re3data"))

            filterKey = "openaire____::re3data";

        LOGGER.debug("Country code equals : " + country);

        LOGGER.debug("Filter mode equals : " + filterKey);

        UriComponents uriComponents = searchSnipperDatasource(String.valueOf(page),String.valueOf(size));

        RequestFilter requestFilter = new RequestFilter();

        requestFilter.setCountry(country);

        requestFilter.setCollectedfrom(filterKey);

        try{

            String rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

            JSONArray jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            while (jsonArray.length() > 0 ) {

                resultSet.addAll(mapper.readValue(String.valueOf(jsonArray),

                        mapper.getTypeFactory().constructCollectionType(List.class, RepositorySnippet.class)));

                page += 1;

                uriComponents = searchSnipperDatasource(String.valueOf(page),String.valueOf(size));

                rs = restTemplate.postForObject(uriComponents.toUri(),requestFilter, String.class);

                jsonArray = (JSONArray) new JSONObject(rs).get("datasourceInfo");

            }

            return resultSet;

        }catch (Exception e){

            LOGGER.debug("Exception on getRepositoriesByCountry" , e);

//            emailUtils.reportException(e);

            throw e;

        }

    }