D-Net

package eu.dnetlib.repo.manager.service.application.exception;

public class RepositoryException extends RuntimeException {

    public RepositoryException(String errorMessage) {

        super(errorMessage);

    }

}

package eu.dnetlib.repo.manager.service.application.config;

import org.apache.commons.lang.ArrayUtils;

import org.apache.log4j.Logger;

import org.springframework.beans.BeansException;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.web.context.ContextLoaderListener;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.XmlWebApplicationContext;

import javax.servlet.ServletContext;

import java.util.Properties;

public class RepoManagerContextLoaderListener extends ContextLoaderListener {

	private static Logger logger = Logger.getLogger(RepoManagerContextLoaderListener.class);

	public RepoManagerContextLoaderListener() {

		super();

	}

	public RepoManagerContextLoaderListener(WebApplicationContext context) {

		super(context);

	}

	@Override

	protected WebApplicationContext createWebApplicationContext(

			ServletContext servletContext)

			throws BeansException {

		logger.debug("Creating web application context");

		Properties props = this.loadProperties();

		String repoMode = props.getProperty("services.validator.mode.repo");

		String userMode = props.getProperty("services.validator.mode.user");

		Boolean standaloneMode = Boolean.parseBoolean(props.getProperty("services.validator.mode.standalone"));

		logger.info("User mode: " + userMode);

		logger.info("Repo mode: " + repoMode);

		logger.info("Standalone mode: " + standaloneMode);

//		logger.info("Dnet workflow enabled: " + repoMode);

		XmlWebApplicationContext ctx = new XmlWebApplicationContext();

		ctx.setServletContext(servletContext);

		String userApiContext = null;

		if (userMode.equalsIgnoreCase("local"))

			userApiContext = "eu/dnetlib/validator/web/api/impls/users/springContext-validator-user-local.xml";

		else if (userMode.equalsIgnoreCase("ldap"))

			userApiContext = "eu/dnetlib/users/springContext-users-ldap.xml";

		String[] springContextCore = new  String[] {

				"classpath:META-INF/cxf/cxf.xml",

				"classpath:META-INF/cxf/cxf-extension-soap.xml",

				"classpath:META-INF/cxf/cxf-extension-jaxws.xml",

				"classpath:META-INF/cxf/cxf-servlet.xml",

				"classpath*:/cxf.xml",

				"classpath*:/eu/dnetlib/repos/ehcacher/springContext-repos-ehcacher.xml",

				"classpath*:/eu/dnetlib/clients/ws/springContext-locatorFactory.xml",

				"classpath*:/eu/dnetlib/soap/cxf/applicationContext-eprbuilders.xml",

//				"classpath*:/eu/dnetlib/validator/web/actions/springContext-validator-struts.xml",

//				"classpath*:/eu/dnetlib/validator/web/actions/springContext-validator-emailer.xml",

//				"classpath*:/eu/dnetlib/validator/web/config/springContext-validator.xml",

				"classpath*:/eu/dnetlib/repo/manager/server/config/springContext-repo-manager-config.xml",

//				"classpath*:/eu/dnetlib/validator/commons/dao/springContext-*.xml",

				"classpath*:/eu/dnetlib/repos/springContext-repos-" + repoMode + ".xml",

				"classpath*:/" + userApiContext

		};

		String[] springContextForStandalone = new String[] {

		};

		String[] springContextForIS = new String[] {

				"classpath*:/gr/uoa/di/driver/util/springContext-locators.xml",

				"classpath*:/gr/uoa/di/driver/app/springContext-lookupFactory.xml",

				"classpath*:/gr/uoa/di/driver/app/springContext-lookupClients.xml",

				"classpath*:/eu/dnetlib/enabling/hcm/springContext-hcmService.xml",

				"classpath*:/gr/uoa/di/driver/app/springContext-commons.xml",

				"classpath*:/gr/uoa/di/driver/app/springContext-registrator.xml"

		};

		if (standaloneMode) {

			logger.debug("Loading contexts for standalone mode");

			ctx.setConfigLocations((String[])ArrayUtils.addAll(springContextCore,springContextForStandalone));

		} else {

			logger.debug("Loading contexts for dnet");

			ctx.setConfigLocations((String[])ArrayUtils.addAll(springContextCore,springContextForIS));

		}

		ctx.refresh();

		logger.debug("done");

		return ctx;

	}	

	private Properties loadProperties() {

		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(new String[] {

				"classpath*:/eu/dnetlib/repo/manager/server/config/springContext-repo-manager-config.xml"

		});

		CascadingPropertyLoader pLoader = (CascadingPropertyLoader) ctx.getBean("propertyLoader");

		Properties props = pLoader.getProperties();

		ctx.destroy();

		ctx.close();

		return props;

	}

}

package eu.dnetlib.repo.manager.service.application.config;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

import java.util.Properties;

/**

 * CascadingPropertyLoader loads a number of property files and mergers them together, so that the last properties

 * override the previous. It also supports property expansion like:

 * 

 * <code>

 *   something = 1

 *   somethingelse = 2

 *   test = ${something}/${somethingelse}

 *  </code>

 * 

 * <p>

 * And if you override something to XX, then test will become XX/2

 * </p>

 * 

 * 

 * @author marko

 * 

 */

public class CascadingPropertyLoader extends PropertyPlaceholderConfigurer implements InitializingBean {

	private Properties properties;

	public void afterPropertiesSet() throws Exception {

		this.properties = mergeProperties();

		// Convert the merged properties, if necessary.

		convertProperties(this.properties);

		logger.debug("Properties: " + properties);

	}

	@Override

	protected void processProperties(final ConfigurableListableBeanFactory beanFactoryToProcess, final Properties props) throws BeansException {

		super.processProperties(beanFactoryToProcess, props);

	}

	public Properties getProperties() {

		return properties;

	}

	public void setProperties(final Properties properties) {

		super.setProperties(properties);

		this.properties = properties;

	}

}

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

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

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;

@RestController

@RequestMapping(value = "/broker")

public interface BrokerApi {

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

    DatasourcesBroker getDatasourcesOfUser(@RequestBody String params);

}

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

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.application.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.application.rest;

import eu.dnetlib.domain.data.Repository;

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

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

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

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

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

import org.springframework.http.ResponseEntity;

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

import org.springframework.stereotype.Component;

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

import java.util.Comparator;

import java.util.List;

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

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

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

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

        DatasourcesBroker ret = new DatasourcesBroker();

        //set for user

        ret.setDatasourcesOfUser(getDatasourcesOfUserType(repoAPI.getRepositoriesOfUser(userEmail, false)));

        //set for shared

        if (includeShared) {

            //TODO whatever nikonas was saying

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

            ret.setSharedDatasources(getDatasourcesOfUserType(repoAPI.getReposByIds(sharedDatasourceIds)));

        }

        //set others

        if (includeByOthers) {

            ret.setDatasourcesOfOthers(getDatasourcesOfUserType(repoAPI.getRepositoriesOfUser(userEmail, true)));

        }

        return null;

    }

    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 : this.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;

    }

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

        /*final String service = "/topicsForDatasource";

        //build the uri params

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("ds", datasourceName);

        //create new template engine

        RestTemplate template = new RestTemplate();

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

        ResponseEntity<List<BrowseEntry>> resp;

        try {

            //communicate with endpoint

            resp = template.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<List<BrowseEntry>>() {

                    });

        } catch (RestClientException e) {

            throw new BrokerException(e);

        }

        return resp.getBody();*/

        return null;

    }

}

package eu.dnetlib.repo.manager.service.application.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.application.rest;

import eu.dnetlib.api.functionality.ValidatorServiceException;

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

import eu.dnetlib.repo.manager.service.application.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.application.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.application.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.application.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.application.rest;

import eu.dnetlib.repo.manager.service.application.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.stereotype.Component;

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

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

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

import java.util.List;

@Component

public class RepositoryApiImpl implements RepositoryApi {

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

    private String baseAddress;

    @Override

    public String getCountries()  {

        return RestService.executeGET(baseAddress + "/ds/countries");

    }

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

    }

    @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() {

        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.application.shared;

/**

 * Created by stefanos on 27-Oct-16.

 */

public class BrokerException extends Exception {

    public BrokerException(Throwable th) {

        super(th);

    }

    public BrokerException() {

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by stefanos on 10-Mar-17.

 */

public enum NotificationMode implements IsSerializable {

    MOCK, EMAIL

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by stefanos on 26/10/2016.

 */

public class Range implements IsSerializable {

    private String min;

    private String max;

    public Range() {

    }

    public Range(final String min, final String max) {

        super();

        this.min = min;

        this.max = max;

    }

    public String getMin() {

        return this.min;

    }

    public void setMin(final String min) {

        this.min = min;

    }

    public String getMax() {

        return this.max;

    }

    public void setMax(final String max) {

        this.max = max;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by stefanos on 10-Mar-17.

 */

public class SimpleSubscriptionDesc implements IsSerializable {

    private String id;

    private String datasource;

    private String topic;

    private long count;

    public SimpleSubscriptionDesc() {

    }

    public SimpleSubscriptionDesc(final String id, final String datasource, final String topic, final long count) {

        this.id = id;

        this.datasource = datasource;

        this.topic = topic;

        this.count = count;

    }

    public String getId() {

        return this.id;

    }

    public void setId(final String id) {

        this.id = id;

    }

    public String getDatasource() {

        return this.datasource;

    }

    public void setDatasource(final String datasource) {

        this.datasource = datasource;

    }

    public String getTopic() {

        return this.topic;

    }

    public void setTopic(final String topic) {

        this.topic = topic;

    }

    public long getCount() {

        return this.count;

    }

    public void setCount(final long count) {

        this.count = count;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by claudio on 26/07/16.

 */

public class Provenance implements IsSerializable {

    private String repositoryName;

    private String url;

    private String id;

    public Provenance() {

    }

    public String getRepositoryName() {

        return repositoryName;

    }

    public void setRepositoryName(String repositoryName) {

        this.repositoryName = repositoryName;

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

import java.util.List;

/**

 * Created by stefanos on 26/10/2016.

 */

public class EventsPage implements IsSerializable{

    private String datasource;

    private String topic;

    private long currPage;

    private long totalPages;

    private long total;

    private List<OpenAireEventPayload> values;

    public EventsPage() {

    }

    public EventsPage(final String datasource, final String topic, final long currPage, final long totalPages, final long total,

                      final List<OpenAireEventPayload> values) {

        this.datasource = datasource;

        this.topic = topic;

        this.currPage = currPage;

        this.totalPages = totalPages;

        this.total = total;

        this.values = values;

    }

    public String getDatasource() {

        return datasource;

    }

    public void setDatasource(String datasource) {

        this.datasource = datasource;

    }

    public String getTopic() {

        return topic;

    }

    public void setTopic(String topic) {

        this.topic = topic;

    }

    public long getCurrPage() {

        return currPage;

    }

    public void setCurrPage(long currPage) {

        this.currPage = currPage;

    }

    public long getTotalPages() {

        return totalPages;

    }

    public void setTotalPages(long totalPages) {

        this.totalPages = totalPages;

    }

    public long getTotal() {

        return total;

    }

    public void setTotal(long total) {

        this.total = total;

    }

    public List<OpenAireEventPayload> getValues() {

        return values;

    }

    public void setValues(List<OpenAireEventPayload> values) {

        this.values = values;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by claudio on 22/07/16.

 */

public class ExternalReference implements IsSerializable {

    private String url;

    private String sitename;

    private String type;

    private String refidentifier;

    public ExternalReference() {

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getSitename() {

        return sitename;

    }

    public void setSitename(String sitename) {

        this.sitename = sitename;

    }

    public String getType() {

        return type;

    }

    public void setType(String type) {

        this.type = type;

    }

    public String getRefidentifier() {

        return refidentifier;

    }

    public void setRefidentifier(String refidentifier) {

        this.refidentifier = refidentifier;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by stefanos on 17/3/2017.

 */

public enum ConditionOperator implements IsSerializable {

    EXACT, MATCH_ANY, MATCH_ALL, RANGE

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by claudio on 22/07/16.

 */

public class Instance implements IsSerializable {

    private String url;

    private String license;

    private String hostedby;

    private String instancetype;

    public Instance() {

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getLicense() {

        return license;

    }

    public void setLicense(String license) {

        this.license = license;

    }

    public String getHostedby() {

        return hostedby;

    }

    public void setHostedby(String hostedby) {

        this.hostedby = hostedby;

    }

    public String getInstancetype() {

        return instancetype;

    }

    public void setInstancetype(String instancetype) {

        this.instancetype = instancetype;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

public class Project implements IsSerializable {

    private String code;

    private String acronym;

    private String title;

    private String funder;

    private String fundingProgram;

    private String jurisdiction;

    public Project() {

    }

    public Project(final String code, final String acronym, final String title, final String funder, final String fundingProgram, final String jurisdiction) {

        this.code = code;

        this.acronym = acronym;

        this.title = title;

        this.funder = funder;

        this.fundingProgram = fundingProgram;

        this.jurisdiction = jurisdiction;

    }

    public String getCode() {

        return code;

    }

    public void setCode(String code) {

        this.code = code;

    }

    public String getAcronym() {

        return acronym;

    }

    public void setAcronym(String acronym) {

        this.acronym = acronym;

    }

    public String getTitle() {

        return title;

    }

    public void setTitle(String title) {

        this.title = title;

    }

    public String getFunder() {

        return funder;

    }

    public void setFunder(String funder) {

        this.funder = funder;

    }

    public String getFundingProgram() {

        return fundingProgram;

    }

    public void setFundingProgram(String fundingProgram) {

        this.fundingProgram = fundingProgram;

    }

    public String getJurisdiction() {

        return jurisdiction;

    }

    public void setJurisdiction(String jurisdiction) {

        this.jurisdiction = jurisdiction;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

import java.util.ArrayList;

import java.util.List;

/**

 * Created by stefanos on 17/3/2017.

 */

public class MapConditions implements IsSerializable {

    private String field;

    private MapValueType fieldType;

    private ConditionOperator operator;

    private List<ConditionParams> listParams = new ArrayList<>();

    public MapConditions() {

    }

    public String getField() {

        return field;

    }

    public void setField(String field) {

        this.field = field;

    }

    public MapValueType getFieldType() {

        return fieldType;

    }

    public void setFieldType(MapValueType fieldType) {

        this.fieldType = fieldType;

    }

    public ConditionOperator getOperator() {

        return operator;

    }

    public void setOperator(ConditionOperator operator) {

        this.operator = operator;

    }

    public List<ConditionParams> getListParams() {

        return listParams;

    }

    public void setListParams(List<ConditionParams> listParams) {

        this.listParams = listParams;

    }

}

package eu.dnetlib.repo.manager.service.application.shared.broker;

import com.google.gwt.user.client.rpc.IsSerializable;

/**

 * Created by stefanos on 10-Mar-17.

 */

public class OpenaireSubscription implements IsSerializable {

    private String subscriber;

    private NotificationFrequency frequency;

    private NotificationMode mode;

    private AdvQueryObject query;

    public OpenaireSubscription() {

    }

    public OpenaireSubscription(final String subscriber, final NotificationFrequency frequency, final

    NotificationMode mode,

                                final AdvQueryObject query) {

        this.subscriber = subscriber;

        this.frequency = frequency;

        this.mode = mode;

        this.query = query;

    }

    public String getSubscriber() {

        return this.subscriber;

    }

    public void setSubscriber(final String subscriber) {

        this.subscriber = subscriber;

    }

    public NotificationFrequency getFrequency() {

        return this.frequency;

    }