D-Net

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

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

import org.springframework.http.MediaType;

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

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

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

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

import java.util.List;

@RestController

@RequestMapping(value = "/monitor")

public interface MonitorApi {

    @RequestMapping(value = "/getJobsOfUser" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)

    List<StoredJob> getJobsOfUser(@RequestBody String params);

    @RequestMapping(value = "/getJobsOfUser" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)

    int getJobsOfUserPerValidationStatus(@RequestBody String params);

    @RequestMapping(value = "/getJobSummary" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)

    StoredJob getJobSummary(@RequestBody String params);

}

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

import eu.dnetlib.api.functionality.ValidatorServiceException;

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

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

import gr.uoa.di.driver.util.ServiceLocator;

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

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

import eu.dnetlib.repo.manager.service.utils.Constants;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import eu.dnetlib.api.functionality.ValidatorService;

import org.json.JSONObject;

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

import org.springframework.stereotype.Component;

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

import javax.annotation.PostConstruct;

@Component

public class ValidatorApiImpl implements ValidatorApi{

    @Autowired

    private MonitorApiImpl monitorApi;

    private ServiceLocator<ValidatorService> validatorServiceLocator;

    private ValidatorService getValidationService() {

        return this.validatorServiceLocator.getService();

    }

    public ServiceLocator<ValidatorService> getValidatorServiceLocator() {

        return validatorServiceLocator;

    }

    public void setValidatorServiceLocator(ServiceLocator<ValidatorService> validatorServiceLocator) {

        this.validatorServiceLocator = validatorServiceLocator;

    }

    private Map<String, List<RuleSet>> rulesetMap = new ConcurrentHashMap<String, List<RuleSet>>();

    @PostConstruct

    private void loadRules(){

        try {

            for (RuleSet ruleSet : getValidationService().getRuleSets()) {

                if (ruleSet.getVisibility() != null && ruleSet.getVisibility().contains("development")) {

                    String key = "";

                    if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_data$"))

                        key = Constants.VALIDATION_MODE_DATA;

                    else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0$") || ruleSet.getGuidelinesAcronym().equals("driver"))

                        key = Constants.VALIDATION_MODE_LITERATURE;

                    else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_cris$"))

                        key = Constants.VALIDATION_MODE_CRIS;

                    if (rulesetMap.containsKey(key))

                        rulesetMap.get(key).add(ruleSet);

                    else {

                        List<RuleSet> ruleSets = new ArrayList<RuleSet>();

                        ruleSets.add(ruleSet);

                        rulesetMap.put(key, ruleSets);

                    }

                }

            }

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

    }

    @Override

    public void submitJobForValidation(JobForValidation jobForValidation) {

        try {

            this.getValidationService().submitValidationJob(jobForValidation);

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

    }

    @Override

    public void reSubmitJobForValidation(String jobId) {

        JSONObject jsonObject = new JSONObject();

        jsonObject.put("jobId",jobId);

        jsonObject.put("groupBy","all");

        StoredJob job = monitorApi.getJobSummary(jsonObject.toString());

        Set<Integer> contentRules = new HashSet<Integer>();

        Set<Integer> usageRules = new HashSet<Integer>();

        RuleSet ruleSet = null;

        for (List<RuleSet> ruleSets : this.rulesetMap.values()) {

            for (RuleSet rSet : ruleSets)

                if (rSet.getGuidelinesAcronym().equals(job.getDesiredCompatibilityLevel())) {

                    ruleSet = rSet;

                    break;

                }

        }

        for (int ruleId : job.getRules()) {

            if (ruleSet.getContentRulesIds().contains(ruleId))

                contentRules.add(ruleId);

            else if (ruleSet.getUsageRulesIds().contains(ruleId))

                usageRules.add(ruleId);

        }

        if (!contentRules.isEmpty())

            job.setSelectedContentRules(contentRules);

        if (!usageRules.isEmpty())

            job.setSelectedUsageRules(usageRules);

        this.submitJobForValidation(job);

    }

    @Override

    public List<RuleSet> getRuleSets() {

        return rulesetMap.get(Constants.VALIDATION_MODE_DATA);

    }

    @Override

    public List<String> getSetsOfRepository(@PathVariable("url") String url) {

        try {

            return OaiTools.getSetsOfRepo(url);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

}

/*

package eu.dnetlib.repo.manager.api.application.rest;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.gwt.shared.Help;

import org.springframework.http.MediaType;

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

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

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

@RestController

@RequestMapping(value = "/help")

public interface HelpApi {

    @RequestMapping(value = "/getHelpById/{id}", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    Help getHelpById(String id) ;

}

*/

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

import eu.dnetlib.api.functionality.ValidatorService;

import eu.dnetlib.api.functionality.ValidatorServiceException;

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

import gr.uoa.di.driver.util.ServiceLocator;

import org.json.JSONObject;

import org.springframework.stereotype.Component;

import java.util.List;

@Component

public class MonitorApiImpl implements MonitorApi {

    private ServiceLocator<ValidatorService> validatorServiceLocator;

    private ValidatorService getValidationService() {

        return this.validatorServiceLocator.getService();

    }

    public ServiceLocator<ValidatorService> getValidatorServiceLocator() {

        return validatorServiceLocator;

    }

    public void setValidatorServiceLocator(ServiceLocator<ValidatorService> validatorServiceLocator) {

        this.validatorServiceLocator = validatorServiceLocator;

    }

    @Override

    public List<StoredJob> getJobsOfUser(String params) {

        JSONObject json_params = new JSONObject(params);

        String user = json_params.getString("user");

        String jobType = json_params.getString("jobType");

        Integer offset = Integer.parseInt(json_params.getString("offset"));

        Integer limit = Integer.parseInt(json_params.getString("limit"));

        String dateFrom = json_params.getString("dateFrom");

        String dateTo = json_params.getString("dateTo");

        String validationStatus = json_params.getString("validationStatus");

        List<StoredJob> jobs = null;

        try {

            jobs = getValidationService().

                    getStoredJobsNew(user, jobType, offset, limit, dateFrom, dateTo, validationStatus);

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

        return jobs;

    }

    @Override

    public int getJobsOfUserPerValidationStatus(String params) {

        JSONObject json_params = new JSONObject(params);

        String user = json_params.getString("user");

        String jobType = json_params.getString("jobType");

        String validationStatus = json_params.getString("validationStatus");

        try {

            return getValidationService().getStoredJobsTotalNumberNew(user, jobType, validationStatus);

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

        return 0;

    }

    @Override

    public StoredJob getJobSummary(String params) {

        JSONObject json_params = new JSONObject(params);

        String jobId = json_params.getString("jobId");

        String groupBy = json_params.getString("groupBy");

        try {

            return getValidationService().getStoredJob(Integer.parseInt(jobId), groupBy);

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

        return null;

    }

}

/*

package eu.dnetlib.repo.manager.api.application.rest;

import eu.dnetlib.gwt.client.help.HelpServiceAsync;

import eu.dnetlib.gwt.shared.Help;

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

import org.springframework.stereotype.Component;

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

@Component

public class HelpApiImpl implements HelpApi{

    @Autowired

    private static HelpServiceAsync helpService;

    @Override

    public Help getHelpById(@PathVariable("id") String id)  {

        return null;

    }

}

*/

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

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import org.springframework.http.MediaType;

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

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

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

import java.util.List;

@RestController

@RequestMapping(value = "/repository")

public interface RepositoryApi {

    @RequestMapping(value = "/getCountries", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    String getCountries() ;

    @RequestMapping(value = "/getRepositoriesByCountry/{country}/{page}/{size}/", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    List<Repository> getRepositoriesByCountry(String country,

                                          String page,

                                          String size) ;

    @RequestMapping(value = "/getRepositoriesOfUser/{userEmail}/{page}/{size}")

    List<Repository> getRepositoriesOfUser( String userEmail,

                                        String page,

                                        String size);

    @RequestMapping(value = "/getRepositoryById/{id}", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    Repository getRepositoryById(String id) ;

    @RequestMapping(value = "/getRepositoriesByName/{name}/{page}/{size}/", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    List<Repository> getRepositoriesByName(String name,

                                          String page,

                                          String size);

    @RequestMapping(value = "/getRepositoryInterface/{id}", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    RepositoryInterface getRepositoyInterface(String id) ;

    @RequestMapping(value = "/addRepository", method = RequestMethod.POST,

            consumes = MediaType.APPLICATION_JSON_VALUE)

    String addRepository(Repository repository);

    @RequestMapping(value = "/addInterface", method = RequestMethod.POST,

            consumes = MediaType.APPLICATION_JSON_VALUE)

    String addRepositoryInterface(RepositoryInterface repositoryInterface);

    @RequestMapping(value = "/getDnetCountries", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    List<String> getDnetCountries();

    @RequestMapping(value = "/getTypologies", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    List<String> getTypologies();

    @RequestMapping(value = "/getTimezones", method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    List<String> getTimezones();

    @RequestMapping(value = "/updateManagedStatus", method = RequestMethod.POST,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String updateManagedStatus(String id,String managed);

    @RequestMapping(value = "/updateEnglishName", method = RequestMethod.POST,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String updateEnglishName(String id,String englishName);

    @RequestMapping(value = "/updateLatitude", method = RequestMethod.POST,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String updateLatitude(String id,String latitude);

    @RequestMapping(value = "/updateLongitude", method = RequestMethod.POST,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String updateLongitude(String id,String longitude);

    @RequestMapping(value = "/updateOfficialName", method = RequestMethod.POST,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String updateOfficialName(String id,String officialName);

    @RequestMapping(value = "/getUrlsOfUserRepos",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    String getUrlsOfUserRepos(String user_email);

}

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

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

import eu.dnetlib.repo.manager.service.shared.broker.BrowseEntry;

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

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import org.json.JSONArray;

import org.json.JSONObject;

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

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 javax.ws.rs.core.UriBuilder;

import java.util.List;

@Component

public class RepositoryApiImpl implements RepositoryApi {

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

    private String baseAddress;

    private RestTemplate restTemplate = null;

    @PostConstruct

    private void init(){

        restTemplate = new RestTemplate();

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

    }

    @Override

    public String getCountries()  {

        UriComponents uriComponents = UriComponentsBuilder

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

                .build().encode();

        return restTemplate.getForObject(uriComponents.toUri(), String.class);

    }

    @Override

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

                                                     @PathVariable("page") String page,

                                                     @PathVariable("size") String size){

       /* String vars = page+"/"+size+"?country="+country;

        String uri = baseAddress+ "/ds/search/country/" + vars;

        JSONArray jsonArray = new JSONArray(RestService.executeGET(uri));

        return Converter.jsonToRepositoryList(jsonArray);*/

        UriComponents uriComponents = UriComponentsBuilder

                                            .fromHttpUrl(baseAddress + "/ds/search/country/")

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

                                            .queryParam("country",country)

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

        RestTemplate template = new RestTemplate();

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

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

        return Converter.jsonToRepositoryList(new JSONArray(rs));

    }

    @Override

    public List<Repository> getRepositoriesOfUser(@PathVariable("userEmail") String userEmail,

                                                  @PathVariable("page") String page,

                                                  @PathVariable("size") String size)  {

        String vars = page+"/"+size+"?contactemail="+userEmail;

        String uri = baseAddress+ "/ds/search/email/" + vars;

        JSONArray jsonArray = new JSONArray(RestService.executeGET(uri));

        return Converter.jsonToRepositoryList(jsonArray);

    }

    @Override

    public Repository getRepositoryById(@PathVariable("id") String id)  {

        String uri = baseAddress+ "/ds/get/" + id;

        JSONObject jsonObject = new JSONObject( RestService.executeGET(uri) );

        return  Converter.jsonToRepositoryObject(jsonObject);

    }

    @Override

    public List<Repository> getRepositoriesByName(@PathVariable("name") String name,

                                                  @PathVariable("page") String page,

                                                  @PathVariable("size") String size) {

        String vars = page+"/"+size+"?name="+name;

        String uri = baseAddress+ "/ds/search/name/" + vars;

        JSONArray jsonArray = new JSONArray(RestService.executeGET(uri));

        return Converter.jsonToRepositoryList(jsonArray);

    }

    @Override

    public RepositoryInterface getRepositoyInterface(@PathVariable("id") String id) {

        String uri = baseAddress+ "/ds/service/" + id;

        JSONArray jsonArray = new JSONArray( RestService.executeGET(uri) );

        return  Converter.jsonToRepositoryInterfaceObject(jsonArray.getJSONObject(0));

    }

    @Override

    public String addRepository(@RequestBody Repository repository) {

        String uri = baseAddress+ "/ds/add/";

        return RestService.executePOST(uri, Converter.repositoryObjectToJson(repository));

    }

    @Override

    public String addRepositoryInterface(RepositoryInterface repositoryInterface) {

        String uri = baseAddress+ "/ds/service/add/";

        return RestService.executePOST(uri, Converter.repositoryInterfaceObjectToJson(repositoryInterface));

    }

    @Override

    public List<String> getDnetCountries() {

        return Converter.readFile("countries.txt");

    }

    @Override

    public List<String> getTypologies() {

        System.out.println("Typologies");

        return Converter.readFile("typologies.txt");

    }

    @Override

    public List<String> getTimezones() {

        return Converter.readFile("timezones.txt");

    }

    @Override

    public String updateManagedStatus(@RequestParam(value = "id")   String id,

                                      @RequestParam(value = "managed")  String managed) {

        String uri = baseAddress+ "/ds/manage?id="+id+"&managed="+managed;

        return RestService.executePOST(uri,null);

    }

    @Override

    public String updateEnglishName(@RequestParam(value = "id")   String id,

                                    @RequestParam(value = "englishname")  String englishName) {

        String uri = baseAddress+ "/ds/manage?dsId="+id+"&englishname="+englishName;

        return RestService.executePOST(uri,null);

    }

    @Override

    public String updateLatitude(@RequestParam(value = "id")   String id,

                                 @RequestParam(value = "managed")  String latitude) {

        String uri = baseAddress+ "/ds/manage?dsId="+id+"&latitude="+latitude;

        return RestService.executePOST(uri,null);

    }

    @Override

    public String updateLongitude(@RequestParam(value = "id")   String id,

                                  @RequestParam(value = "longitude")  String longitude) {

        String uri = baseAddress+ "/ds/manage?dsId="+id+"&longitude="+longitude;

        return RestService.executePOST(uri,null);

    }

    @Override

    public String updateOfficialName(@RequestParam(value = "id")   String id,

                                     @RequestParam(value = "officialname")  String officialname) {

        String uri = baseAddress+ "/ds/manage?dsId="+id+"&officialname="+officialname;

        return RestService.executePOST(uri,null);

    }

    @Override

    public String getUrlsOfUserRepos(@PathVariable("user_email") String user_email) {

        //TODO create service a join datasource d for user u method

        return null;

    }

}

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

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

import eu.dnetlib.repo.manager.service.shared.broker.BrowseEntry;

import eu.dnetlib.repo.manager.service.shared.broker.DatasourcesBroker;

import eu.dnetlib.repo.manager.service.shared.broker.EventsPage;

import org.springframework.http.MediaType;

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

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

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

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

import java.util.List;

@RestController

@RequestMapping(value = "/broker")

public interface BrokerApi {

    @RequestMapping(value = "/getDatasourcesOfUser" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)

    DatasourcesBroker getDatasourcesOfUser(@RequestBody String params) throws BrokerException;

    @RequestMapping(value = "/getTopicsForDatasource/{datasourceName}" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)

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

    @RequestMapping(value = "/advancedShowEvents" , method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)

    EventsPage advancedShowEvents(@RequestBody String params) throws BrokerException;

}

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

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

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

@Component

public class RestService {

    private static RestTemplate restTemplate = new org.springframework.web.client.RestTemplate();

    public static String executeGET(String uri){

        return  restTemplate.getForObject(uri,String.class);

    }

    public static String executePOST(String uri,String json){

        return  restTemplate.postForObject(uri,json,String.class);

    }

}

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

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

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

import org.springframework.http.MediaType;

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

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

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

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

import java.util.List;

@RestController

@RequestMapping(value = "/validator")

public interface ValidatorApi {

    @RequestMapping(value = "/submitJobForValidation",method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE )

    void submitJobForValidation(@RequestBody JobForValidation jobForValidation);

    @RequestMapping(value = "/reSubmitJobForValidation/",method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE )

    void reSubmitJobForValidation(@RequestBody String jobId);

    @RequestMapping(value = "/getRuleSets" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)

    List<RuleSet> getRuleSets();

    @RequestMapping(value = "/getSetsOfRepository/{url}" , method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)

    List<String> getSetsOfRepository(String url);

}

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

import com.fasterxml.jackson.databind.ObjectMapper;

import com.google.gson.Gson;

import eu.dnetlib.domain.data.Repository;

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

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

import eu.dnetlib.repo.manager.service.shared.broker.AdvQueryObject;

import eu.dnetlib.repo.manager.service.shared.broker.BrowseEntry;

import eu.dnetlib.repo.manager.service.shared.broker.DatasourcesBroker;

import eu.dnetlib.repo.manager.service.shared.broker.EventsPage;

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.HttpEntity;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

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

import org.springframework.stereotype.Component;

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.util.MultiValueMap;

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

import org.springframework.web.client.RestClientException;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.*;

@Component

public class BrokerApiImpl implements BrokerApi {

    @Autowired

    private RepositoryApiImpl repoAPI;

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

    private String openairePath;

    @Override

    public DatasourcesBroker getDatasourcesOfUser(String params) {

        JSONObject json_params = new JSONObject(params);

        DatasourcesBroker ret = new DatasourcesBroker();

        String userEmail = json_params.getString("userEmail");

        boolean includeShared = json_params.getBoolean("includeShared");

        boolean includeByOthers = json_params.getBoolean("includeByOthers");

        try {

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

            if (includeShared) {

                //TODO whatever nikonas was saying

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

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

            }

            if (includeByOthers) {

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

            }

        } catch (BrokerException e) {

            e.printStackTrace();

        }

        return ret;

    }

    @Override

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

        final String service = "/topicsForDatasource";

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("ds", datasourceName);

        RestTemplate template = new RestTemplate();

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

        ResponseEntity<List<BrowseEntry>> resp;

        try {

            resp = template.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<List<BrowseEntry>>() {

                    });

        } catch (RestClientException e) {

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    @Override

    public EventsPage advancedShowEvents(String params) throws BrokerException {

        JSONObject json_params = new JSONObject(params);

        long page = json_params.getLong("page");

        long pagesize = json_params.getLong("pagesize");

        JSONObject json_advQueryObject = json_params.getJSONObject("advQueryObject");

        ObjectMapper obj = new ObjectMapper();

        AdvQueryObject advQueryObject = new Gson().fromJson(json_advQueryObject.toString(),AdvQueryObject.class);

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

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

        uriParams.put("page", page);

        uriParams.put("pageSize", pagesize);

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

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

        headers.add("Content-Type", "application/json");

        advQueryObject.setPage(page);

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

        RestTemplate template = new RestTemplate();

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

        ResponseEntity<EventsPage> resp;

        try {

            resp = template.exchange(

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

                    HttpMethod.POST,

                    entity,

                    new ParameterizedTypeReference<EventsPage>() {

                    }

            );

        } catch (RestClientException 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){

        int page = 1;

        int size = 10;

        List<Repository> rs = null;

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

        while (true){

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

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

            resultSet.addAll(rs);

        }

        return resultSet;

    }

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

        return null;

    }

}

CONTENTdm

Digibib

Digital Commons

DigiTool

DIVA

Diva-Portal

dLibra

Doks

Drupal

DSpace

Earmas

EPrints

ETD

ETD-db

Fedora

Fez

Greenstone

HAL

invenio

MyCoRe

Open Repository

OPUS

Pica-Verbundkatalog

Proprietary Software

PUMA

PURE

SciELO

SFIX

VITAL

VTOAI

WEKO

XooNIps

------------------------

OJS

HyperJournal

ePubTk

GAPworks

DPubS

E-Journal

------------------------

[Other]

Afghanistan

Albania

Algeria

Andorra

Angola

Antigua & Deps

Argentina

Armenia

Australia

Austria

Azerbaijan

Bahamas

Bahrain

Bangladesh

Barbados

Belarus

Belgium

Belize

Benin

Bhutan

Bolivia

Bosnia Herzegovina

Botswana

Brazil

Brunei

Bulgaria

Burkina

Burundi

Cambodia

Cameroon

Canada

Cape Verde

Central African Rep

Chad

Chile

China

Colombia

Comoros

Congo

Congo {Democratic Rep}

Costa Rica

Croatia

Cuba

Cyprus

Czech Republic

Denmark

Djibouti

Dominica

Dominican Republic

East Timor

Ecuador

Egypt

El Salvador

Equatorial Guinea

Eritrea

Estonia

Ethiopia

Fiji

Finland

France

Gabon

Gambia

Georgia

Germany

Ghana

Greece

Grenada

Guatemala

Guinea

Guinea-Bissau

Guyana

Haiti

Honduras

Hungary

Iceland

India

Indonesia

Iran

Iraq

Ireland {Republic}

Israel

Italy

Ivory Coast

Jamaica

Japan

Jordan

Kazakhstan

Kenya

Kiribati

Korea North

Korea South

Kosovo

Kuwait

Kyrgyzstan

Laos

Latvia

Lebanon

Lesotho

Liberia

Libya

Liechtenstein

Lithuania

Luxembourg

Macedonia

Madagascar

Malawi

Malaysia

Maldives

Mali

Malta

Marshall Islands

Mauritania

Mauritius

Mexico

Micronesia

Moldova

Monaco

Mongolia

Montenegro

Morocco

Mozambique

Myanmar, {Burma}

Namibia

Nauru

Nepal

Netherlands

New Zealand

Nicaragua

Niger

Nigeria

Norway

Oman

Pakistan

Palau

Panama

Papua New Guinea

Paraguay

Peru

Philippines

Poland

Portugal

Qatar

Romania

Russian Federation

Rwanda

St Kitts & Nevis

St Lucia

Saint Vincent & the Grenadines

Samoa

San Marino

Sao Tome & Principe

Saudi Arabia

Senegal

Serbia

Seychelles

Sierra Leone

Singapore

Slovakia

Slovenia

Solomon Islands

Somalia

South Africa

Spain

Sri Lanka

Sudan

Suriname

Swaziland

Sweden

Switzerland

Syria

Taiwan

Tajikistan

Tanzania

Thailand

Togo

Tonga

Trinidad & Tobago

Tunisia

Turkey

Turkmenistan

Tuvalu

Uganda

Ukraine

United Arab Emirates

United Kingdom

United States

Uruguay

Uzbekistan

Vanuatu

Vatican City

Venezuela

Vietnam

Yemen

Zambia

Zimbabwe

-2.0	[GMT - 2] Fernando de Noronha Time,	South Georg...

-1.0	[GMT - 1] Azores Standard Time, Cape Verde Time...

0.0	[GMT] Western European Time, Greenwich Mean Time

1.0	[GMT + 1] Central European Time, West African Time

2.0	[GMT + 2] Eastern European Time, Central Africa...

3.0	[GMT + 3] Moscow Standard Time, Eastern African...

3.5	[GMT + 3:30] Iran Standard Time

4.0	[GMT + 4] Gulf Standard Time, Samara Standard Time

4.5	[GMT + 4:30] Afghanistan Time

5.0	[GMT + 5] Pakistan Standard Time, Yekaterinburg...

8.0	[GMT + 8] Beijing, Hong Kong, Irkutsk, Kuala Lumpur, Manila, Perth

    public static Repository jsonToRepositoryObject(JSONObject jsonObject) {

    public static List<Repository> jsonToRepositoryList(JSONArray rs) {

    public static RepositoryInterface jsonToRepositoryInterfaceObject(JSONObject jsonObject) {

    public static String repositoryObjectToJson(Repository repository) {

    public static String repositoryInterfaceObjectToJson(RepositoryInterface repositoryInterface) {