D-Net

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

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

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

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

import org.apache.commons.lang.NotImplementedException;

import org.json.JSONException;

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

import org.springframework.http.*;

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

import org.springframework.stereotype.Service;

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.web.client.RestClientException;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import javax.annotation.PostConstruct;

import java.io.IOException;

import java.io.InputStream;

import java.util.*;

@Service("brokerService")

public class BrokerServiceImpl implements BrokerService {

    private RepositoryServiceImpl repoAPI;

    @Value("${services.broker.url}:${services.broker.port}/${services.broker.api}${services.broker.openaire}")

    @Value("${services.broker.url}:${services.broker.port}/${services.broker.api}")

    @Value("${topic_types.url}")

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

            .getLogger(BrokerServiceImpl.class);

    @Autowired

    RestTemplate restTemplate;

    private HttpHeaders httpHeaders;

    private HashMap<String, Term> topics = new HashMap<String, Term>();

    @Autowired

    @PostConstruct

        httpHeaders = new HttpHeaders();

        LOGGER.debug("Init dnet topics!");

        try (InputStream is = new URL(topicsURL).openStream()) {

            ObjectMapper mapper = new ObjectMapper();

            for (JsonNode term : root.path("terms"))

                topics.put(term.path("code").textValue(), parseTerm(term));

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

            emailUtils.reportException(e);

        }

        return new Term(term.path("englishName").textValue(), term.path("nativeName").textValue(),

    }

    @Override

    public DatasourcesBroker getDatasourcesOfUser(String user, String includeShared, String includeByOthers) throws JSONException {

        long start = System.currentTimeMillis();

        DatasourcesBroker ret = new DatasourcesBroker();

            ret.setDatasourcesOfUser(getDatasourcesOfUserType(repoAPI.getRepositoriesSnippetsOfUser(user, "0", "100")));

            //TODO fix bug when values are true

//            if (Boolean.parseBoolean(includeShared)) {

//            if (Boolean.parseBoolean(includeByOthers)) {

        } catch (Exception e) {

            emailUtils.reportException(e);

        }

        long end = System.currentTimeMillis();

        System.out.println("Getting datasources of user in " + (end - start) + "ms");

        return ret;

    @Override

    public List<BrowseEntry> getTopicsForDatasource(String datasourceName) throws BrokerException {

        final String service = "/topicsForDatasource";

            resp = restTemplate.exchange(

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

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    public EventsPage advancedShowEvents(String page,

                                         AdvQueryObject advQueryObject) throws BrokerException, JSONException, IOException {

        uriParams.put("page", Long.parseLong(page));

        uriParams.put("pageSize", Long.parseLong(size));

        advQueryObject.setPage(Long.parseLong(page));

        HttpEntity<AdvQueryObject> entity = new HttpEntity<>(advQueryObject, httpHeaders);

        ResponseEntity<EventsPage> resp;

            resp = restTemplate.exchange(

                    builder.buildAndExpand(uriParams).encode().toUri(),

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    private List<Tuple<BrowseEntry, String>> getDatasourcesOfUserType(List<RepositorySnippet> repositories) throws BrokerException {

        List<Tuple<BrowseEntry, String>> entries = new ArrayList<>();

        for (RepositorySnippet repo : repositories) {

            BrowseEntry temp = new BrowseEntry();

            temp.setValue(repo.getOfficialname());

            temp.setSize(new Long(0));

            for (BrowseEntry e : getTopicsForDatasource(repo.getOfficialname())) {

                temp.setSize(temp.getSize() + e.getSize());

        long stop = System.currentTimeMillis();

        System.out.println("getDatasourcesOfUserType returned in " + (stop - start) + "ms ");

    @Override

    public EventsPage showEvents(String datasourceName,

        final String service = "/events";

                .path("/{page}/{size}/");

            resp = restTemplate.exchange(

                    builder.build().expand(page, size).encode().toUri(),

                    HttpMethod.GET,

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    @Override

    public Map<String, List<SimpleSubscriptionDesc>> getSimpleSubscriptionsOfUser(String userEmail)

            throws BrokerException {

        final String service = "/subscriptions";

        LOGGER.debug(builder.build().encode().toUri());

        ResponseEntity<Map<String, List<SimpleSubscriptionDesc>>> resp;

            resp = restTemplate.exchange(

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

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    public Map<String, List<SimpleSubscriptionDesc>> getSimpleSubscriptionsOfUserByRepoId(String userEmail, String repoId) throws BrokerException {

        throw new NotImplementedException();

    }

    public Subscription subscribe(OpenaireSubscription obj) throws BrokerException {

        final String service = "/subscribe";

        HttpEntity<OpenaireSubscription> entity = new HttpEntity<>(obj, httpHeaders);

            resp = restTemplate.exchange(

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

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    public ResponseEntity<Object> unsubscribe(String subscriptionId) throws BrokerException {

        final String service = "/subscriptions/" + subscriptionId;

            restTemplate.exchange(

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

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

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

    }

    public Subscription getSubscription(String subscriptionId) throws BrokerException {

        final String service = "/subscriptions/" + subscriptionId;

            resp = restTemplate.exchange(

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

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    @Override

    @Override

    public EventsPage getNotificationsBySubscriptionId(String subscriptionId,

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(openairePath + "/notifications/")

                .path("/{id}/{page}/{size}/")

                .build().expand(subscriptionId, page, size).encode();

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

    //@Override

    public Map<String, List<Subscription>> getSubscriptionsOfUser(String userEmail)

            throws BrokerException {

        Map<String, List<SimpleSubscriptionDesc>> simpleSubs = getSimpleSubscriptionsOfUser(userEmail);

        Map<String, List<Subscription>> subs = new HashMap<>();

        List<Subscription> subscriptions = null;

        for (String s : simpleSubs.keySet()) {

            List<SimpleSubscriptionDesc> simpleSubscriptionDescs = simpleSubs.get(s);

            for (SimpleSubscriptionDesc simpleSubscriptionDesc : simpleSubscriptionDescs) {

                subscriptions = new ArrayList<>();

            subs.put(s, subscriptions);

        }

}