D-Net

{

"type_source": "SVN",

"goal": "package -U source:jar",

"url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/uoa-repository-manager-gui/trunk/",

"deploy_repository": "dnet45-snapshots",

"version": "4",

"mail": "antleb@di.uoa.gr",

"deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots",

"name": "uoa-repository-manager-gui"

}

package eu.dnetlib.repo.manager.server.utils;

import eu.dnetlib.domain.functionality.UserProfile;

/**

 * Created by nikonas on 11/12/15.

 */

public interface EmailUtils {

    void sendActivationEmail(UserProfile user, String activationId) throws Exception;

    void sendResetPasswordEmail(String user, String securityCode) throws Exception;

    void reportException(Exception exception);

}

package eu.dnetlib.repo.manager.server.utils;

import org.apache.log4j.Logger;

import org.dom4j.io.DOMWriter;

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

import org.w3c.dom.Document;

import se.kb.oai.OAIException;

import se.kb.oai.pmh.*;

import javax.net.ssl.*;

import javax.xml.namespace.NamespaceContext;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.security.cert.X509Certificate;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

public class OaiTools {

	{

		disableSslVerification();

	}

	private static Logger LOGGER = Logger.getLogger(OaiTools.class);

	public static List<String> getSetsOfRepo(String baseUrl) throws Exception {

		try {

			LOGGER.debug("Getting sets of repository " + baseUrl);

			OaiPmhServer harvester = new OaiPmhServer(baseUrl);

			SetsList setList = harvester.listSets();

			ResumptionToken token = setList.getResumptionToken();

			List<Set> sets = new ArrayList<Set>();

			sets.addAll(setList.asList());

			while (token != null) {

				setList = harvester.listSets(token);

				token = setList.getResumptionToken();

				sets.addAll(setList.asList());

			}

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

			for (Set set : sets) {

				ret.add(set.getSpec().trim());

			}

			if (ret.size() > 0 )

				Collections.sort(ret);

			return ret;

		} catch (Exception e) {

			LOGGER.error("Error getting sets of repository " + baseUrl, e);

			return new ArrayList<String>();

			//throw e;

		}

	}

	public static boolean identifyRepository(String baseUrl) throws Exception {

		LOGGER.debug("sending identify request to repo " + baseUrl);

		OaiPmhServer harvester = new OaiPmhServer(baseUrl);

		if (baseUrl.trim().isEmpty()) {

			return false;

		}

		try {

			Identification identification = harvester.identify();

			DOMWriter d4Writer = new DOMWriter();

			Document d = d4Writer.write(identification.getResponse());

			return verifyIdentify(d);

		} catch (Exception e) {

			LOGGER.debug("Error verifying identify response", e);

			throw e;

		}

	}

	private static boolean verifyIdentify(Document doc) throws XPathExpressionException {

		NamespaceContext ctx = new NamespaceContext() {

			public String getNamespaceURI(String prefix) {

				String uri;

				if (prefix.equals("oai"))

					uri = "http://www.openarchives.org/OAI/2.0/";

				else

					uri = null;

				return uri;

			}

			// Dummy implementation - not used!

			public Iterator<String> getPrefixes(String val) {

				return null;

			}

			// Dummy implemenation - not used!

			public String getPrefix(String uri) {

				return null;

			}

		};

		// Now the XPath expression

		String xpathStr = "//oai:OAI-PMH/oai:Identify";

		XPathFactory xpathFact = XPathFactory.newInstance();

		XPath xpath = xpathFact.newXPath();

		xpath.setNamespaceContext(ctx);

		String result = xpath.evaluate(xpathStr, doc);

		return (result != null && !result.equals(""));

	}

	private static void disableSslVerification() {

		try

		{

			LOGGER.debug("disabling ssl verification");

			// Create a trust manager that does not validate certificate chains

			TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {

				public java.security.cert.X509Certificate[] getAcceptedIssuers() {

					return null;

				}

				public void checkClientTrusted(X509Certificate[] certs, String authType) {

				}

				public void checkServerTrusted(X509Certificate[] certs, String authType) {

				}

			}

			};

			// Install the all-trusting trust manager

			SSLContext sc = SSLContext.getInstance("SSL");

			sc.init(null, trustAllCerts, new java.security.SecureRandom());

			HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

			// Create all-trusting host name verifier

			HostnameVerifier allHostsValid = new HostnameVerifier() {

				public boolean verify(String hostname, SSLSession session) {

					return true;

				}

			};

			// Install the all-trusting host verifier

			HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);

		} catch (NoSuchAlgorithmException e) {

			LOGGER.error("disabling ssl verification", e);

		} catch (KeyManagementException e) {

			LOGGER.error("error while disabling ssl verification", e);

		}

	}

}

package eu.dnetlib.repo.manager.server.utils;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.repo.manager.server.config.CascadingPropertyLoader;

import eu.dnetlib.utils.MailLibrary;

import org.apache.log4j.Logger;

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

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

import org.springframework.stereotype.Component;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.io.Writer;

import java.util.ArrayList;

import java.util.List;

/**

 * Created by nikonas on 11/12/15.

 */

@Component

public class EmailUtilsImpl implements EmailUtils {

    private static Logger LOGGER = Logger.getLogger(EmailUtilsImpl.class);

    private List<String> specialRecipients = new ArrayList<String>();

    private boolean override = false, logonly = false;

    private String overrideEmail = null, from = null;

    @Autowired

    private MailLibrary mailLibrary;

    @Autowired

    private CascadingPropertyLoader pLoader;

    @Value("${services.repo-manager.baseUrl}")

    private String baseUrl;

    @Value("${services.repo-manager.adminEmail}")

    private String adminEmail;

    @Override

    public void sendActivationEmail(UserProfile user, String activationId) throws Exception {

        try {

            this.sendMail(user.getEmail(), getEmailProperty("user.registration.mail.subject"), "Dear " + user.getFirstname() + " " + user.getLastname() + ",\n" + getEmailProperty("user.registration.mail.message") + ": " + this.baseUrl + "?activationId=" + activationId + "#activateAccount", false, null);

        } catch (Exception e) {

            LOGGER.error("Error while sending activation email to user: " + user.getEmail(), e);

            throw e;

        }

    }

    @Override

    public void sendResetPasswordEmail(String email, String securityCode) throws Exception {

        try {

            this.sendMail(email, getEmailProperty("user.forgotPassword.mail.Subject"), getEmailProperty("user.forgotPassword.mail.Body1") + ": " + this.baseUrl + "?securityCode=" + securityCode + "#resetPassword" + "\n\n" + getEmailProperty("user.forgotPassword.mail.Body2") + ": " + securityCode, false, null);

        } catch (Exception e) {

            LOGGER.error("Error while sending activation email to user: " + email, e);

            throw e;

        }

    }

    @Override

    public void reportException(Exception exception) {

        Writer writer = new StringWriter();

        PrintWriter printWriter = new PrintWriter(writer);

        exception.printStackTrace(printWriter);

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

        try {

            recipients.add(this.adminEmail);

            String message = "An exception has occurred:\n"+writer.toString();

            String subject = "Automatic Bug Report";

            this.sendMail(recipients, subject, message, false, null);

        } catch (Exception e) {

            LOGGER.error("Error sending error report", e);

        }

    }

    private void sendMail(String email, String subject, String message, boolean sendToSpecial, List<String> repoAdminMails) throws Exception {

        ArrayList<String> to = new ArrayList<String>();

        to.add(email);

        this.sendMail(to,subject,message,sendToSpecial,repoAdminMails);

    }

    private void sendMail(List<String> recipients, String subject, String message, boolean sendToSpecial, List<String> repoAdminMails) throws Exception {

        try {

            if (sendToSpecial) {

                recipients.addAll(this.specialRecipients);

            }

            if (repoAdminMails != null)

                recipients.addAll(repoAdminMails);

            if (this.override) {

                recipients.clear();

                recipients.add(overrideEmail);

            }

            if (!logonly)

                mailLibrary.sendEmail(recipients.toArray(new String[]{}), subject, message);

            LOGGER.debug("Sending mail to Recipients: " + recipients + " Subject: " + subject + " Message: " + message);

        } catch (Exception e) {

            LOGGER.error("Error sending mail to Recipients: " + recipients + " Subject: " + subject + " Message: " + message, e);

            throw new Exception(e);

        }

    }

    private String getEmailProperty(String key) {

        return pLoader.getProperties().getProperty(key);

    }

    public void setSpecialRecipients(String specialRecipients) {

        String[] recps = specialRecipients.split(",");

        for (String recp : recps) {

            recp = recp.trim();

            this.specialRecipients.add(recp);

        }

    }

    public void setOverride(boolean override) {

        this.override = override;

    }

    public void setOverrideEmail(String overrideEmail) {

        this.overrideEmail = overrideEmail;

    }

    public String getFrom() {

        return from;

    }

    public void setFrom(String from) {

        this.from = from;

    }

    public boolean isLogonly() {

        return logonly;

    }

    public void setLogonly(boolean logonly) {

        this.logonly = logonly;

    }

}

package eu.dnetlib.repo.manager.server.utils;

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

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

import org.apache.log4j.Logger;

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

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

@Configurable

public class LocalVocabularies implements IsSerializable {

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

	public static String loggedInField = "LOGGED_IN_FIELD";

	public static List<String> typologies;

	public static List<String> countries;

	public static List<Timezone> timezones;

	public static final String MODE_LOCAL = "local";

	public static final String MODE_DNET = "dnet";

	public static final String MODE_LDAP = "ldap";

	public static final String ENV_LAREFERENCIA = "lareferencia";

	public static final String ENV_MINCYT = "mincyt";

	public static final String ENV_OPENAIRE_PRODUCTION = "openaire-production";

	public static final String ENV_OPENAIRE_BETA = "openaire-beta";

	public static final String ENV_DEVELOPMENT = "development";

	static {

		typologies = new ArrayList<String>();

		countries = new ArrayList<String>();

		timezones = new ArrayList<Timezone>();

		try {

			logger.debug("loading typologies, countries, timezones and other constants");

			BufferedReader br = new BufferedReader(new InputStreamReader(LocalVocabularies.class.getResourceAsStream("/eu/dnetlib/repo/manager/server/utils/typologies.txt")));

			String line;

			while((line = br.readLine()) != null) {

				typologies.add(line.trim());

			}

			br.close();

			br = new BufferedReader(new InputStreamReader(LocalVocabularies.class.getResourceAsStream("/eu/dnetlib/repo/manager/server/utils/countries.txt")));

			while((line = br.readLine()) != null) {

				countries.add(line.trim());

			}

			br.close();

			br = new BufferedReader(new InputStreamReader(LocalVocabularies.class.getResourceAsStream("/eu/dnetlib/repo/manager/server/utils/timezones.txt")));

			while((line = br.readLine()) != null) {

				String parts[] = line.split("\t");

				if(parts.length < 2 || parts.length > 2)

					continue;

				String name = parts[1].trim();

				double offset = Double.parseDouble(parts[0].trim());

				Timezone timezone = new Timezone(name, offset);

				timezones.add(timezone);

			}

			br.close();

		} catch (Exception e) {

			logger.error("Error loading typologies, countries, timezones and other constants", e);

		}

	}

}

package eu.dnetlib.repo.manager.server.services;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.gwt.server.service.SpringGwtRemoteServiceServlet;

import eu.dnetlib.repo.manager.client.services.UserService;

import eu.dnetlib.repo.manager.server.utils.EmailUtils;

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

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

import eu.dnetlib.users.UserApi;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.regex.Pattern;

/**

 * Created by nikonas on 12/7/15.

 */

@Service("userService")

public class UserServiceImpl extends SpringGwtRemoteServiceServlet implements UserService {

    private static final Logger LOGGER = Logger

            .getLogger(UserServiceImpl.class);

    @Autowired

    private UserApi userAPI;

    @Autowired

    private EmailUtils emailUtils;

    public void init(ServletConfig config) throws ServletException {

        LOGGER.info("initializing user service impl ");

        super.init(config);

    }

    @Override

    public Tuple<UserProfile, String> login(String email_username, String password) throws UserAccessException {

        LOGGER.info("Checking credentials for user " + email_username);

        try {

            String email = email_username;

            Pattern rfc2822 = Pattern.compile("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$");

            if (!rfc2822.matcher(email_username.trim().toLowerCase()).matches()) {

                LOGGER.debug("user logged in using username");

                email = this.userAPI.getEmailFromUsername(email_username);

            }

            if (email == null) {

                throw new UserAccessException("login.userNotExists", UserAccessException.ErrorCode.INVALID_USERNAME);

            }

            if (!this.userAPI.userExists(email)) {

                throw new UserAccessException("login.userNotExists", UserAccessException.ErrorCode.INVALID_USERNAME);

            }

            if (!this.userAPI.isUserActivated(email)) {

                throw new UserAccessException("login.notActivated", UserAccessException.ErrorCode.NOT_ACTIVATED);

            }

            if (!this.userAPI.correctCreds(email, password)) {

                throw new UserAccessException("login.InvalidPassword", UserAccessException.ErrorCode.INVALID_PASSWORD);

            }

            UserProfile userProfile = this.userAPI.getUser(email);

            String role = "";

            String[] adminEmails = new String[] {"stefania.martziou@gmail.com" , "antleb@di.uoa.gr", "ant.lebesis@gmail.com", "natalia@di.uoa.gr", "pedroprincipe@sdum.uminho.pt", "dpierrakos@gmail.com", "jochen.schirrwagen@uni-bielefeld.de", "aenne.loehden@uni-bielefeld.de"};

            if(Arrays.asList(adminEmails).contains(userProfile.getEmail()))

                role = "admin";

            return new Tuple<>(userProfile, role);

        } catch (Exception e) {

            LOGGER.error("An error occurred while checking credentials for user " + email_username, e);

            emailUtils.reportException(e);

            if (e instanceof UserAccessException) {

                throw (UserAccessException) e;

            }

            else {

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public Tuple<UserProfile, String> getUserByEmail(String email) throws UserAccessException {

        LOGGER.info("Getting user with email " + email);

        try {

            UserProfile userProfile = this.userAPI.getUser(email);

            String role = "";

            String[] adminEmails = new String[] {"stefania.martziou@gmail.com" , "antleb@di.uoa.gr", "ant.lebesis@gmail.com", "natalia@di.uoa.gr", "pedroprincipe@sdum.uminho.pt", "dpierrakos@gmail.com", "jochen.schirrwagen@uni-bielefeld.de", "aenne.loehden@uni-bielefeld.de"};

            if(Arrays.asList(adminEmails).contains(userProfile.getEmail()))

                role = "admin";

            return new Tuple<>(userProfile, role);

        } catch (Exception e) {

            LOGGER.error("An error occurred while getting user with email " + email, e);

            emailUtils.reportException(e);

            throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void register(UserProfile userProfile) throws UserAccessException {

        try {

            LOGGER.info("Registering user " + userProfile.getEmail());

            Pattern rfc2822 = Pattern.compile("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$");

            if (!rfc2822.matcher(userProfile.getEmail().trim().toLowerCase()).matches()) {

                throw new UserAccessException("login.notValidEmail", UserAccessException.ErrorCode.INVALID_EMAIL_FORMAT);

            }

            if (this.userAPI.usernameExists(userProfile.getUsername())) {

                throw new UserAccessException("login.usernameAlreadyExists", UserAccessException.ErrorCode.USERNAME_ALREADY_EXISTS);

            }

            if (this.userAPI.userExists(userProfile.getEmail())) {

                throw new UserAccessException("login.mailAlreadyExists", UserAccessException.ErrorCode.MAIL_ALREADY_EXISTS);

            }

//            String activationId = "TEST";

            String activationId = this.userAPI.addUser(userProfile.getUsername(), userProfile.getEmail(), userProfile.getPassword(), userProfile.getFirstname(), userProfile.getLastname(), userProfile.getInstitution());

            emailUtils.sendActivationEmail(userProfile, activationId);

        } catch (Exception e) {

            LOGGER.error("Error while registering user " + userProfile.getEmail(), e);

            emailUtils.reportException(e);

            if (e instanceof UserAccessException)

                throw (UserAccessException) e;

            else

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void activateUser(String activationId) throws UserAccessException {

        try {

            LOGGER.info("Activating user with activation with activation id " + activationId);

            if (!this.userAPI.activateUser(activationId))

                throw new UserAccessException("registration.okAccountAlreadyActivation", UserAccessException.ErrorCode.ALREADY_ACTIVATED);

        } catch (Exception e) {

            LOGGER.error("Error while activating user account with activation id " + activationId, e);

            emailUtils.reportException(e);

            if (e instanceof UserAccessException)

                throw (UserAccessException) e;

            else

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void updateUser(UserProfile userProfile) throws UserAccessException {

        try {

            LOGGER.info("Editing user " + userProfile.getUsername());

            Pattern rfc2822 = Pattern.compile("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$");

            if (!rfc2822.matcher(userProfile.getEmail().trim().toLowerCase()).matches()) {

                throw new UserAccessException("login.notValidEmail", UserAccessException.ErrorCode.INVALID_EMAIL_FORMAT);

            }

            String currentEmail = this.userAPI.getEmailFromUsername(userProfile.getUsername());

            if (!userProfile.getEmail().equalsIgnoreCase(currentEmail)) {

                if (this.userAPI.userExists(userProfile.getEmail())) {

                    throw new UserAccessException("login.mailAlreadyExists", UserAccessException.ErrorCode.MAIL_ALREADY_EXISTS);

                }

            }

            this.userAPI.editUser(userProfile);

        } catch (Exception e) {

            LOGGER.error("Error while editing user " + userProfile.getUsername(), e);

            if (e instanceof UserAccessException)

                throw (UserAccessException) e;

            else

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void prepareResetPassword(String email) throws UserAccessException {

        try {

            LOGGER.debug("Sending password recovery to user " + email);

            if (!this.userAPI.userExists(email)) {

                throw new UserAccessException("login.userNotExists", UserAccessException.ErrorCode.INVALID_USERNAME);

            }

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

            to.add(email);

            String securityCode = this.userAPI.prepareResetPassword(email);

            emailUtils.sendResetPasswordEmail(email, securityCode);

        } catch (Exception e) {

            LOGGER.error("Error while sending password recovery to user " + email, e);

            emailUtils.reportException(e);

            if (e instanceof UserAccessException)

                throw (UserAccessException) e;

            else

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void resetPassword(String securityCode, String password) throws UserAccessException {

        try {

            LOGGER.debug("Reseting password with security code " + securityCode);

            if (securityCode.length() == 0) {

                throw new UserAccessException("resetPassword.wrongSecurityCode", UserAccessException.ErrorCode.WRONG_SECURITY_CODE);

            }

            this.userAPI.resetPassword(securityCode, password);

        } catch (Exception e) {

            LOGGER.error("Error while reseting password with security code " + securityCode);

            emailUtils.reportException(e);

            if (e instanceof UserAccessException)

                throw (UserAccessException) e;

            else

                throw new UserAccessException("login.generalError", UserAccessException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void resendActivation(String email) throws UserAccessException {

    }

}

package eu.dnetlib.repo.manager.server.services;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.unboundid.util.Base64;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.domain.enabling.Vocabulary;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.gwt.server.service.SpringGwtRemoteServiceServlet;

import eu.dnetlib.repo.manager.client.services.RepositoryService;

import eu.dnetlib.repo.manager.server.utils.EmailUtils;

import eu.dnetlib.repo.manager.server.utils.LocalVocabularies;

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

import eu.dnetlib.repos.RepoApi;

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

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.commons.lang.WordUtils;

import org.apache.log4j.Logger;

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

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

import org.springframework.dao.EmptyResultDataAccessException;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

import java.io.IOException;

import java.text.Normalizer;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

/**

 * Created by nikonas on 12/8/15.

 */

@SuppressWarnings("serial")

@Service("repositoryService")

public class RepositoryServiceImpl extends SpringGwtRemoteServiceServlet implements RepositoryService {

    private static final Logger LOGGER = Logger

            .getLogger(RepositoryServiceImpl.class);

    @Autowired

    private RepoApi repoAPI;

    @Autowired

    private EmailUtils emailUtils;

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

    @Autowired

    private VocabularyLoader vocabularyLoader;

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

    @Value("${services.repo-manager.repository.testing.mode}")

    private boolean testingMode;

    @Autowired

    private PiwikDAO piwikDAO;

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

    private String analyticsURL;

    private static final String PIWIK_SCRIPT = StringEscapeUtils.escapeHtml("<!-- Piwik -->\n" +

            "<script type=\"text/javascript\">\n" +

            "\tvar _paq = _paq || [];\n" +

            "\t_paq.push(['enableLinkTracking']);\n" +

            "\t(function() {\n" +

            "\t\tvar u=\"//analytics.openaire.eu/\";\n" +

            "\t\t_paq.push(['setTrackerUrl', u+'piwik.php']);\n" +

            "\t\t_paq.push(['setSiteId', $$$]);\n" +

            "\t\t<% if(handle != null){%>\n" +

            "\t\t\t_paq.push(['setCustomVariable', 1, 'oaipmhID',\"oai:<%= baseUrl %>:<%=handle %>\", 'page']);\n" +

            "\t\t\t_paq.push(['trackPageView']);\n" +

            "\t\t<}>\n" +

            "\t\tvar d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];\n" +

            "\t\tg.type='text/javascript'; g.async=true; g.defer=true; g.src=u+'piwik.js'; s.parentNode.insertBefore(g,s);\n" +

            "\t})();\n" +

            "</script>\n" +

            "<noscript>\n" +

            "\t<p>\n" +

            "\t\t<img src=\"//analytics.openaire.eu/piwik.php?idsite=47\" style=\"border:0;\" alt=\"\" />\n" +

            "\t</p>\n" +

            "</noscript>\n" +

            "<!— End Piwik Code —>");

    @PostConstruct

    public void init() {

        this.loadVocabularies();

    }

    @Override

    public Tuple<List<Repository>, List<Repository>> getRepositoriesByCountry(String country, String mode, boolean includeUnknownCountries) throws RepositoryServiceException {

        try {

            if (testingMode)

                return this.getRepositoriesByCountryTesting(country, mode, includeUnknownCountries);

            LOGGER.debug("Getting repositories of country: " + country + " with type: " + mode + " and includeUnknownCountries: " + includeUnknownCountries);

            Tuple<List<Repository>, List<Repository>> retTuple = new Tuple<List<Repository>, List<Repository>>();

            List<Repository> reposList = this.repoAPI.getRepositoriesPerCountry(mode).get(country);

            if (reposList == null) {

                retTuple.setFirst(new ArrayList<Repository>());

//                if (!includeUnknownCountries) {

//                    throw new RepositoryServiceException("registration.noReposForThisCountry", RepositoryServiceException.ErrorCode.NO_REPOS_FOR_THIS_COUNTRY);

//                }

            } else {

                retTuple.setFirst(reposList);

            }

            if (includeUnknownCountries) {

                List<Repository> withoutCountryList = this.repoAPI.getRepositoriesPerCountry(mode).get("Without Country");

                List<Repository> unknownCountryList = this.repoAPI.getRepositoriesPerCountry(mode).get("UNKNOWN");

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

                if (withoutCountryList != null)

                    totalList.addAll(withoutCountryList);

                if (unknownCountryList != null)

                    totalList.addAll(unknownCountryList);

                retTuple.setSecond(totalList);

            }

            return retTuple;

        } catch (Exception e) {

            LOGGER.error("Error while getting repositories of country: " + country + " with type: " + mode + " and includeUnknownCountries: " + includeUnknownCountries, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public List<Repository> getRepositoriesByCountry(String country, String mode) throws RepositoryServiceException {

        return this.getRepositoriesByCountry(country, mode, false).getFirst();

    }

    @Override

    public DatasourcesCollection getRepositoriesOfUser(String userEmail, boolean includeShared, boolean includeByOthers) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting repositories of user: " + userEmail + " . IncludeShared: " + includeShared + " . IncludeByOthers: " + includeByOthers);

            DatasourcesCollection retDatasources = new DatasourcesCollection();

            retDatasources.setDatasourcesOfUser(this.repoAPI.getRepositoriesOfUser(userEmail, false));

            if (includeShared) {

                //TODO create dao to save-get shared datasourcesIDs

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

                retDatasources.setSharedDatasources(this.repoAPI.getReposByIds(sharedDatasourceIds));

            }

            if (includeByOthers)

                retDatasources.setDatasourcesOfUser(this.repoAPI.getRepositoriesOfUser(userEmail, true));

            return retDatasources;

        } catch (Exception e) {

            LOGGER.error("Error while getting repositories of user: " + userEmail + " . IncludeShared: " + includeShared + " . IncludeByOthers: " + includeByOthers, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public List<String> getRepositoryUrlsOfUser(String userEmail, boolean includeShared, boolean includeByOthers) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting repositories(urls) of user: " + userEmail + " . IncludeShared: " + includeShared + " . IncludeByOthers: " + includeByOthers);

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

            retRepos.addAll(this.repoAPI.getUrlsOfRepos(userEmail, false));

            return retRepos;

        } catch (Exception e) {

            LOGGER.error("Error while getting repositories(urls) of user: " + userEmail + " . IncludeShared: " + includeShared + " . IncludeByOthers: " + includeByOthers, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public Repository getRepository(String repoId) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting repository with id: " + repoId);

            Repository repo = this.repoAPI.getRepository(repoId);

            if (repo != null) {

                for (RepositoryInterface iFace : repo.getInterfaces()) {

                    if (!iFace.getContentDescription().equals("file::hybrid") && iFace.getAccessProtocol().equalsIgnoreCase("oai")) {

                        iFace.setComplianceName(getComplianceName(iFace.getCompliance()));

                        if (iFace.getCompliance().equals("notCompatible"))

                            iFace.setComplianceName("not compatible");

                    }

                }

            } else

                throw new RepositoryServiceException("registration.repositoryNotExists", RepositoryServiceException.ErrorCode.REPOSITORY_NOT_EXISTS);

            return repo;

        } catch (Exception e) {

            LOGGER.error("Error while getting repository with id: " + repoId, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public Map<String, String> getCountries(Boolean existingOnly, String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting countries");

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

            Map<String, String> countriesMap = new TreeMap<String, String>();

            if (existingOnly) {

                LOGGER.debug("using the repositories map");

                countries.addAll(this.repoAPI.getRepositoriesByCountry(mode).keySet());

            } else {

                LOGGER.debug("using \"dnet:countries\" vocabulary");

                countries.addAll(this.getVocabulary("dnet:countries").getEnglishNames());

            }

            for (String country : countries) {

                countriesMap.put(country, WordUtils.capitalizeFully(country));

            }

            return countriesMap;

        } catch (Exception e) {

            LOGGER.error("Error while getting getting countries", e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public Map<String, String> getCountries() throws RepositoryServiceException {

        return this.getCountries(false, null);

    }

    @Override

    public List<Timezone> getTimezones() throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting timezones from file");

            return LocalVocabularies.timezones;

        } catch (Exception e) {

            LOGGER.error("Error while getting timezones from file", e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public List<String> getTypologies() throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting typologies from file");

            return LocalVocabularies.typologies;

        } catch (Exception e) {

            LOGGER.error("Error while getting typologies from file", e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public Map<String, String> getDatasourceClasses(String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting datasource classes for mode: " + mode);

            Map<String, String> retMap = new HashMap<String, String>();

            for (Map.Entry<String, String> entry : this.getVocabulary("dnet:datasource_typologies").getAsMap().entrySet()) {

                if (mode.equalsIgnoreCase("aggregator")) {

                    if (entry.getKey().contains("aggregator"))

                        retMap.put(entry.getKey(), entry.getValue());

                } else if (mode.equalsIgnoreCase("journal")) {

                    if (entry.getKey().contains("journal"))

                        retMap.put(entry.getKey(), entry.getValue());

                } else if (mode.equalsIgnoreCase("opendoar")) {

                    if (entry.getKey().contains("pubsrepository"))

                        retMap.put(entry.getKey(), entry.getValue());

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

                    if (entry.getKey().contains("datarepository"))

                        retMap.put(entry.getKey(), entry.getValue());

                }

            }

            return retMap;

        } catch (Exception e) {

            LOGGER.error("Error while getting datasource classes for mode: " + mode, e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public Map<String, String> getCompatibilityClasses(String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting compatibility classes for mode: " + mode);

            Map<String, String> retMap = new HashMap<String, String>();

            Map<String, String> compatibilityClasses = this.getVocabulary("dnet:compatibilityLevel").getAsMap();

            boolean foundData = false;

            for (Map.Entry<String, String> entry : compatibilityClasses.entrySet()) {

                if (mode.equalsIgnoreCase(Constants.REPOSITORY_MODE_ALL))

                    return compatibilityClasses;

                else if (mode.equalsIgnoreCase(Constants.REPOSITORY_MODE_RE3DATA)) {

                    if (entry.getKey().matches("^openaire[1-9].0_data$")) {

                        retMap.put(entry.getKey(), entry.getValue());

                        foundData = true;

                    }

                } else {

                    if (entry.getKey().matches("^openaire[1-9].0$") || entry.getKey().equals("driver"))

                        retMap.put(entry.getKey(), entry.getValue());

                }

            }

            //TODO TO BE REMOVED WHEN VOCABULARIES ARE UPDATED

            if (mode.equalsIgnoreCase(Constants.REPOSITORY_MODE_RE3DATA) && !foundData)

                retMap.put("openaire2.0_data", "OpenAIRE Data (funded, referenced datasets)");

            return retMap;

        } catch (Exception e) {

            LOGGER.error("Error while getting compatibility classes for mode: " + mode, e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void storeRepository(Repository repo, String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Storing repository with name: " + repo.getOfficialName());

            List<RepositoryInterface> interfacesToRegister = new ArrayList<RepositoryInterface>();

            //TODO update map

            repo.setCountryCode(getCountryCode(repo.getCountryName()));

            repo.setActivationId(UUID.randomUUID().toString());

//            repo.setRegisteredBy((String) session.get(LocalVocabularies.loggedInField));

            if (mode.equals("opendoar") || mode.equals("re3data")) {

                repo.setProvenanceActionClass("sysimport:crosswalk:entityregistry");

            } else if (mode.equals("journal")) {

                repo.setProvenanceActionClass("user:insert");

                repo.setCollectedFrom("infrastruct_::openaire");

                if (repo.getIssn() != null && repo.getIssn().length() == 0)

                    repo.setIssn(Base64.encode(repo.getOfficialName()).substring(0, 8));

                repo.setId("openaire____::issn" + repo.getIssn());

                repo.setNamespacePrefix("issn" + repo.getIssn());

            } else if (mode.equals("aggregator")) {

                repo.setProvenanceActionClass("user:insert");

                repo.setCollectedFrom("infrastruct_::openaire");

                repo.setId("openaire____::" + Base64.encode(repo.getOfficialName()));

                repo.setNamespacePrefix(Normalizer.normalize(repo.getOfficialName().toLowerCase().replace(" ", "_"), Normalizer.Form.NFD).replaceAll("[^a-zA-Z0-9]", ""));

                if (repo.getNamespacePrefix().length() > 12) {

                    repo.setNamespacePrefix(repo.getNamespacePrefix().substring(0, 12));

                } else {

                    while (repo.getNamespacePrefix().length() < 12)

                        repo.setNamespacePrefix(repo.getNamespacePrefix().concat("_"));

                }

            }

            this.repoAPI.storeRepository(repo, mode, interfacesToRegister);

        } catch (Exception e) {

            LOGGER.error("Error while Storing repository with name: " + repo.getOfficialName(), e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public void updateRepositoryInformation(Repository repo) throws RepositoryServiceException {

        try {

            LOGGER.debug("Updating information of repo: " + repo.getOfficialName());

            this.repoAPI.updateRepositoryInformation(repo);

        } catch (Exception e) {

            LOGGER.error("Error while updating information of repo: " + repo.getOfficialName(), e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public RepositoryInterface updateInterface(RepositoryInterface iFace, String repoId, String datatype) throws RepositoryServiceException {

        try {

            LOGGER.debug("updating interface with id: " + iFace.getId());

            RepositoryInterface retIface = null;

            retIface = this.repoAPI.updateRepositoryInterfaceWithoutChecks(repoId, iFace, datatype);

            retIface.setComplianceName(this.getComplianceName(retIface.getCompliance()));

            return retIface;

        } catch (Exception e) {

            LOGGER.error("error updating interface with id: " + iFace.getId(), e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public RepositoryInterface insertInterface(RepositoryInterface iFace, String repoId, String datatype) throws RepositoryServiceException {

        try {

            LOGGER.debug("inserting interface with id: " + iFace.getId());

            RepositoryInterface retIface = null;

            retIface = this.repoAPI.insertRepositoryInterfaceWithoutChecks(repoId, iFace, datatype);

            retIface.setComplianceName(this.getComplianceName(retIface.getCompliance()));

            return retIface;

        } catch (Exception e) {

            LOGGER.error("error updating interface with id: " + iFace.getId(), e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public void deleteInterface(String repoId, RepositoryInterface iFace, String datatype) throws RepositoryServiceException {

        List<RepositoryInterface> iFaces = new ArrayList<RepositoryInterface>();

        iFaces.add(iFace);

        this.deleteInterfaces(repoId, iFaces, datatype);

    }

    @Override

    public void deleteInterfaces(String repoId, List<RepositoryInterface> iFaces, String datatype) throws RepositoryServiceException {

        try {

            LOGGER.debug("deleting interfaces of repo: " + repoId);

            this.repoAPI.deleteRepositoryInterfacesWithoutChecks(repoId, iFaces, datatype);

        } catch (Exception e) {

            LOGGER.error("deleting interfaces of repo: " + repoId, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public DatasourceVocabularies getDatasourceVocabularies(String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting vocabularies for datasource with type: " + mode);

            DatasourceVocabularies vocs = new DatasourceVocabularies();

            vocs.setCountries(this.getCountries());

            vocs.setDatasourceClasses(this.getDatasourceClasses(mode));

            vocs.setTimezones(this.getTimezones());

            vocs.setTypologies(this.getTypologies());

            vocs.setCompatibilityLevels(this.getCompatibilityClasses(mode));

            return vocs;

        } catch (Exception e) {

            LOGGER.error("Error while getting vocabularies for datasource with type: \" + mode", e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    private Tuple<List<Repository>, List<Repository>> getRepositoriesByCountryTesting(String country, String mode, boolean includeUnknownCountries) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting testing repositories of country: " + country + " with type: " + mode + " and includeUnknownCountries: " + includeUnknownCountries);

            Tuple<List<Repository>, List<Repository>> retTuple = new Tuple<List<Repository>, List<Repository>>();

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

            reposList.add(this.repoAPI.getRepository("opendoar____::1356"));

            reposList.add(this.repoAPI.getRepository("opendoar____::2678"));

            reposList.add(this.repoAPI.getRepository("opendoar____::2980"));

            reposList.add(this.repoAPI.getRepository("opendoar____::1347"));

            reposList.add(this.repoAPI.getRepository("opendoar____::2984"));

            retTuple.setFirst(reposList);

            if (includeUnknownCountries) {

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

                totalList.add(this.repoAPI.getRepository("opendoar____::3000"));

                totalList.add(this.repoAPI.getRepository("opendoar____::1027"));

                totalList.add(this.repoAPI.getRepository("opendoar____::1096"));

                retTuple.setSecond(totalList);

            }

            return retTuple;

        } catch (Exception e) {

            LOGGER.error("Error while getting testing repositories of country: " + country + " with type: " + mode + " and includeUnknownCountries: " + includeUnknownCountries, e);

            if (e instanceof RepositoryServiceException) {

                throw (RepositoryServiceException) e;

            } else {

                emailUtils.reportException(e);

                throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

            }

        }

    }

    @Override

    public String getLatestUpdateDateOfList(String mode) throws RepositoryServiceException {

        try {

            LOGGER.debug("Getting latest update date of list: " + mode);

            return this.repoAPI.getListLatestUpdate(mode).split("T")[0];

        } catch (Exception e) {

            LOGGER.error("Error while getting latest update date of list: " + mode, e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public PiwikInfo getPiwikSiteForRepository(String repoId) throws RepositoryServiceException {

        try {

            return this.piwikDAO.getPiwikSiteForRepo(repoId);

        } catch (EmptyResultDataAccessException e) {

            return null;

        }

    }

    @Override

    public void enableMetricsForRepository(Repository repository, UserProfile requestor) throws RepositoryServiceException {

        String URL = analyticsURL + "siteName=" + repository.getOfficialName() + "&url=" + repository.getWebsiteUrl();

        //TODO uncomment when we can communitcate with the piwik (create site)

//        try {

//            Map<String, Object> map = new ObjectMapper().readValue(URL, Map.class);

//

//            String siteId = (String) map.get("value");

            String siteId = new Random(new Date().getTime()).nextInt(200) + "";

            String authenticationToken = new Random(new Date().getTime()).nextInt(1000000000) + "";

            PiwikInfo piwikInfo = new PiwikInfo();

            piwikInfo.setRepositoryId(repository.getId());

            piwikInfo.setRepositoryName(repository.getOfficialName());

            piwikInfo.setCountry(repository.getCountryName());

            piwikInfo.setSiteId(siteId);

            piwikInfo.setAuthenticationToken(authenticationToken);

            piwikInfo.setRequestorEmail(requestor.getEmail());

            piwikInfo.setRequestorName(requestor.getFirstname() + " " + requestor.getLastname());

            piwikInfo.setApproved(false);

            this.piwikDAO.savePiwikInfo(piwikInfo);

            //TODO send this in an email as well to the usage stats admin list

//        } catch (IOException e) {

//            LOGGER.error("Error while creating piwik site", e);

//            emailUtils.reportException(e);

//            throw new RepositoryServiceException("login.generalError", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

//        }

    }

    @Override

    public String getPiwikScriptForRepository(String repoId) throws RepositoryServiceException {

        try {

            PiwikInfo piwikInfo = this.piwikDAO.getPiwikSiteForRepo(repoId);

            String piwikScript = PIWIK_SCRIPT.replace("$$$", piwikInfo.getSiteId());

            return piwikScript;

        } catch (EmptyResultDataAccessException e) {

            return null;

        }

    }

    @Override

    public List<PiwikInfo> getPiwikSitesForRepositories() throws RepositoryServiceException {

        try {

            List<PiwikInfo> piwikInfos = new ArrayList<>();

            piwikInfos = this.piwikDAO.getPiwikSitesForRepos();

            return piwikInfos;

        } catch (EmptyResultDataAccessException e) {

            LOGGER.error("Error while getting list of piwik sites: ", e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("General error", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    @Override

    public void approvePiwikSite(String repositoryId) throws RepositoryServiceException {

        try {

            this.piwikDAO.approvePiwikSite(repositoryId);

        } catch (EmptyResultDataAccessException e) {

            LOGGER.error("Error while approving piwik site: ", e);

            emailUtils.reportException(e);

            throw new RepositoryServiceException("General error", RepositoryServiceException.ErrorCode.GENERAL_ERROR);

        }

    }

    private String getCountryCode(String countryName) {

        Vocabulary countries = this.getVocabulary("dnet:countries");

        return countries.getEncoding(countryName);

    }

    private String getDatasourceClassCode(String datasourceClassName) {

        Vocabulary datasourceClasses = this.getVocabulary("dnet:datasource_typologies");

        return datasourceClasses.getEncoding(datasourceClassName);

    }

    private String getComplianceName(String complianceCode) {

        Vocabulary compatibilityLevels = this.getVocabulary("dnet:compatibilityLevel");

        return compatibilityLevels.getEnglishName(complianceCode);

    }

    private Vocabulary getVocabulary(String vocName) {

        if (!vocabularyMap.containsKey(vocName)) {

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

        }

        return vocabularyMap.get(vocName);

    }

    @Scheduled(fixedRate = 3600000)

    private void loadVocabularies() {

        LOGGER.debug("loading vocabularies");

        for (String vocName : vocabularyNames) {

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

        }

    }

}

package eu.dnetlib.repo.manager.server.services;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.gwt.server.service.SpringGwtRemoteServiceServlet;

import eu.dnetlib.repo.manager.client.services.BrokerService;

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

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

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

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

import eu.dnetlib.repos.RepoApi;

import org.apache.log4j.Logger;

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

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import java.util.*;

/**

 * Created by stefanos on 10/26/16.

 */

@SuppressWarnings("serial")

@Service("brokerService")

public class BrokerServiceImpl extends SpringGwtRemoteServiceServlet implements BrokerService {

    private static final Logger LOGGER = Logger

            .getLogger(BrokerServiceImpl.class);

    @Autowired

    private RepoApi repoAPI;

    @Override

    public void init(ServletConfig config) throws ServletException {

        super.init(config);

        LOGGER.info("broker service init");

    }

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

    /**

     * @param datasourceName the name of the data source

     * @return a list of BrowseEvent entries for that datasource

     * @throws BrokerException containing the error code from the server

     * @author stefanos

     */

    @Override

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

    }

    /**

     * @param datasourceName the name of the datasource

     * @param topic          the name of the topic to filter

     * @param page           the page number

     * @return an Events page with a constant 50 max number of entires

     * @throws BrokerException containing the error code from the server

     */

    @Override

    public EventsPage showEvents(String datasourceName, String topic, long page) throws BrokerException {

        final String service = "/showEvents";

        //build the uri params

        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(openairePath + service)

                .queryParam("ds", datasourceName)

                .queryParam("topic", topic)

                .queryParam("page", page);

        //create new template engine

        RestTemplate template = new RestTemplate();

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

        ResponseEntity<EventsPage> resp;

        try {

            //communicate with endpoint

            resp = template.exchange(

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

                    HttpMethod.GET,

                    null,

                    new ParameterizedTypeReference<EventsPage>() {

                    });

        } catch (RestClientException e) {

            throw new BrokerException(e);

        }

        return resp.getBody();

    }

    /**

     * @param advQueryObject a pojo class containing the filter parameters

     * @param page           the number of the page

     * @param pageSize       the page size

     * @return

     * @throws BrokerException

     */

    @Override

    public EventsPage advancedShowEvents(AdvQueryObject advQueryObject, long page, long pageSize) throws BrokerException {

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

        // URI (URL) parameters

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

        uriParams.put("page", page);

        uriParams.put("pageSize", pageSize);

        //build the uri params

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

        //Header info

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

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

        advQueryObject.setPage(page);

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