D-Net

package eu.dnetlib.repo.manager.service;

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.dnetlib.domain.data.Repository;

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

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

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

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

import org.json.JSONException;

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.stereotype.Service;

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.util.MultiValueMap;

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.io.InputStream;

import java.net.URL;

import java.util.*;

@Service("brokerService")

public class BrokerServiceImpl implements BrokerService {

    @Autowired

    private RepositoryServiceImpl repoAPI;

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

    private String openairePath;

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

    private String apiPath;

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

    private String topicsURL;

    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

    private EmailUtils emailUtils;

    @PostConstruct

    private void initDnetTopicsMap() {

        httpHeaders = new HttpHeaders();

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

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

        InputStream is = null;

        try {

            is = new URL(topicsURL).openStream();

            ObjectMapper mapper = new ObjectMapper();

            JsonNode root = mapper.readTree(is);

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

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

        } catch (IOException e) {

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

            emailUtils.reportException(e);

        }

    }

    private Term parseTerm(JsonNode term) {

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

                term.path("encoding").textValue(),term.path("code").textValue());

    }

    @Override

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

        DatasourcesBroker ret = new DatasourcesBroker();

        try {

            ret.setDatasourcesOfUser(getDatasourcesOfUserType(getRepositoriesOfUser(user)));

            //TODO fix bug when values are true

            if (Boolean.parseBoolean(includeShared)) {

                List<String> sharedDatasourceIds = new ArrayList<String>();

                ret.setSharedDatasources(getDatasourcesOfUserType(getRepositoriesByIds(sharedDatasourceIds)));

            }

            if (Boolean.parseBoolean(includeByOthers)) {

                ret.setDatasourcesOfOthers(getDatasourcesOfUserType(getRepositoriesOfUser(user)));

            }

        } catch (BrokerException e) {

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

            emailUtils.reportException(e);

        }

        return ret;

    }

    @Override

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

        final String service = "/topicsForDatasource";

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("ds", datasourceName);

        ResponseEntity<List<BrowseEntry>> resp;

        try {

            resp = restTemplate.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<List<BrowseEntry>>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

    public EventsPage advancedShowEvents(String page,

                                         String size,

                                         AdvQueryObject advQueryObject) throws BrokerException, JSONException ,IOException {

        final String service = "/events/{page}/{pageSize}";

        Map<String, Long> uriParams = new HashMap<>();

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

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

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service);

        MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();

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

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

        ResponseEntity<EventsPage> resp;

        try {

            resp = restTemplate.exchange(

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

                    HttpMethod.POST,

                    entity,

                    new ParameterizedTypeReference<EventsPage>() {

                    }

            );

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

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

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

        for (Repository 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());

            }

            Tuple<BrowseEntry, String> tup = new Tuple<>(temp, repo.getLogoUrl());

            entries.add(tup);

        }

        // sort the collection by the second field of the tuple which is size

        Collections.sort(entries, new Comparator<Tuple<BrowseEntry, String>>() {

            @Override

            public int compare(Tuple<BrowseEntry, String> e1, Tuple<BrowseEntry, String> e2) {

                return (int) (e2.getFirst().getSize().longValue() - e1.getFirst().getSize().longValue());

            }

        });

        return entries;

    }

    private List<Repository> getRepositoriesOfUser(String userEmail) throws JSONException {

        int page = 0;

        int size = 50;

        List<Repository> rs ;

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

        while (true){

            rs = repoAPI.getRepositoriesOfUser(userEmail, String.valueOf(page), String.valueOf(size));

            resultSet.addAll(rs);

            page+=1;

            if(rs.size() == 0) break;

        }

        return resultSet;

    }

    private List<Repository> getRepositoriesByIds(List<String> sharedDatasourceIds) {

        return null;

    }

    @Override

    public EventsPage showEvents(String datasourceName,

                                 String topic,

                                 String page,

                                 String size) throws BrokerException, JSONException {

        final String service = "/events";

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("ds", datasourceName)

                .queryParam("topic", topic)

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

        ResponseEntity<EventsPage> resp;

        try {

            resp = restTemplate.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<EventsPage>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

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

            throws BrokerException {

        final String service = "/subscriptions";

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("email", userEmail);

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

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

        try {

            resp = restTemplate.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<Map<String, List<SimpleSubscriptionDesc>>>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

    public Subscription subscribe(OpenaireSubscription obj) throws BrokerException {

        final String service = "/subscribe";

        //build the uri params

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service);

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

        //create new template engine

        RestTemplate template = new RestTemplate();

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

        ResponseEntity<Subscription> resp;

        try {

            //communicate with endpoint

            resp = restTemplate.exchange(

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

                    HttpMethod.POST,

                    entity,

                    new ParameterizedTypeReference<Subscription>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

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

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

        //build the uri params

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(apiPath + service);

        try {

            //communicate with endpoint

            restTemplate.exchange(

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

                    HttpMethod.DELETE,

                    null,

                    new ParameterizedTypeReference<Void>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

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

    }

    @Override

    public Subscription getSubscription( String subscriptionId) throws BrokerException {

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

        //build the uri params

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(apiPath + service);

        ResponseEntity<Subscription> resp;

        try {

            //communicate with endpoint

            resp = restTemplate.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<Subscription>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

    public Map<String, Term> getDnetTopics() throws BrokerException {

        return topics;

    }

    @Override

    public EventsPage getNotificationsBySubscriptionId(String subscriptionId,

                                                       String page,

                                                       String size) throws BrokerException {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(openairePath + "/notifications/")

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

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

        ResponseEntity<EventsPage> resp;

        try {

            resp = restTemplate.exchange(

                    uriComponents.toUri(),

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<EventsPage>() {

                    });

        } catch (RestClientException e) {

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

            emailUtils.reportException(e);

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    //@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<>();

                subscriptions.add(getSubscription(simpleSubscriptionDesc.getId()));

            }

            subs.put(s,subscriptions);

        }

        return subs;

    }

}