D-Net

import eu.dnetlib.repo.manager.service.config.RepoManagerContextLoaderListener;

import eu.dnetlib.repo.manager.service.config.RepoManagerContextLoaderListener;

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

import org.springframework.test.context.web.WebAppConfiguration;

    <bean class="eu.dnetlib.repo.manager.service.config.CascadingPropertyLoader"

    <bean class="eu.dnetlib.repo.manager.service.config.CascadingPropertyLoader"

    <bean class="eu.dnetlib.repo.manager.service.config.SwaggerConfig"/>

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

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

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

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

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

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.*;

public class Converter {

    private static final Logger LOGGER = Logger.getLogger(Converter.class);

    public static Repository jsonToRepositoryObject(JSONObject repositoryObject) throws JSONException {

        Repository repository = new Repository();

        JSONObject datasource = repositoryObject.getJSONObject("datasource");

        //if( datasource.equals(null))

        //    return null;

        repository.setId(datasource.get("id").toString());

        repository.setOfficialName(datasource.get("officialname").toString());

        repository.setEnglishName( datasource.get("englishname").toString());

        if(repository.getEnglishName().equals("null"))

            repository.setEnglishName("");

        repository.setWebsiteUrl(datasource.get("websiteurl").toString());

        if(repository.getWebsiteUrl().equals("null"))

            repository.setWebsiteUrl("");

        repository.setLogoUrl(datasource.get("logourl").toString());

        if(repository.getLogoUrl().equals("null"))

            repository.setLogoUrl("");

        repository.setContactEmail(datasource.get("contactemail").toString());

        if(repository.getContactEmail().equals("null"))

            repository.setContactEmail("");

        repository.setLatitude( toDouble(datasource.get("latitude").toString()));

        repository.setLongitude(toDouble(datasource.get("longitude").toString()));

        Double timezone = toDouble(datasource.get("timezone").toString());

        repository.setTimezone(timezone!=null?timezone:0.0);

        repository.setNamespacePrefix(datasource.get("namespaceprefix").toString());

        repository.setOdLanguages(datasource.get("languages").toString());

        repository.setDateOfValidation(convertStringToDate( datasource.get("dateofvalidation").toString()));

        /*  typology -> platform

         *  datasource class -> typology */

        repository.setTypology(datasource.get("platform").toString());

        if(repository.getTypology().equals("null"))

            repository.setTypology("");

        repository.setDatasourceClass(datasource.get("typology").toString());

        repository.setDateOfCollection(convertStringToDate( datasource.get("dateofcollection").toString()));

        repository.setActivationId(datasource.get("activationId").toString());

        repository.setDescription(datasource.get("description").toString());

        if(repository.getDescription().equals("null"))

            repository.setDescription("");

        repository.setIssn(datasource.get("issn").toString());

        repository.setLissn(datasource.get("lissn").toString());

        if(repository.getLissn().equals("null"))

            repository.setLissn("");

        repository.setEissn(datasource.get("eissn").toString());

        if(repository.getEissn().equals("null"))

            repository.setEissn("");

        repository.setRegisteredBy(datasource.get("registeredby").toString());

        /* managed field */

        repository.setRegistered(Boolean.parseBoolean(datasource.get("managed").toString()));

        //subjects

        repository.setAggregator(datasource.get("aggregator").toString());

        repository.setCollectedFrom(datasource.get("collectedfrom").toString());

        //TODO change organization to list

        JSONArray organizations = ((JSONArray)datasource.get("organizations"));

        if(organizations.length() != 0) {

            repository.setOrganization(((JSONArray) datasource.get("organizations")).getJSONObject(0).get("legalname").toString());

            String countryCode = ((JSONArray) datasource.get("organizations")).getJSONObject(0).get("country").toString();

            repository.setCountryCode(countryCode);

        }

        /* identities field  */

        return repository;

    }

    public static Date convertStringToDate(String date){

        if(Objects.equals(date, "null"))

            return null;

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

        try {

            return formatter.parse(date);

        } catch (ParseException e) {

            e.printStackTrace();

        }

        return null;

    }

    public static String convertDateToString(Date date){

        if(Objects.equals(date, null))

            return null;

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

        return formatter.format(date);

    }

    public static Double toDouble(String number){

        if(Objects.equals(number, "null"))

            return 0.0;

        else

            return Double.valueOf(number);

    }

    public static List<RepositorySnippet> jsonToRepositorySnippetList(JSONObject json) throws JSONException {

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

        JSONArray rs = json.getJSONArray("datasourceInfo");

        for(int i=0;i<rs.length();i++)

            resultSet.add(jsonToRepositorySnippetObject( rs.getJSONObject(i)) );

        return resultSet;

    }

    private static RepositorySnippet jsonToRepositorySnippetObject(JSONObject repositorySnippetObject) throws JSONException {

        RepositorySnippet repositorySnippet = new RepositorySnippet();

//        JSONObject datasource = repositorySnippetObject.getJSONObject("datasource");

        repositorySnippet.setId(repositorySnippetObject.get("id").toString());

        repositorySnippet.setOfficialname(repositorySnippetObject.get("officialname").toString());

        repositorySnippet.setEnglishname( repositorySnippetObject.get("englishname").toString());

        if(repositorySnippet.getEnglishname().equals("null"))

            repositorySnippet.setEnglishname("");

        repositorySnippet.setWebsiteurl(repositorySnippetObject.get("websiteurl").toString());

        if(repositorySnippet.getWebsiteurl().equals("null"))

            repositorySnippet.setWebsiteurl("");

        repositorySnippet.setRegisteredby(repositorySnippetObject.get("registeredby").toString());

        if(repositorySnippet.getRegisteredby().equals("null"))

            repositorySnippet.setRegisteredby("");

        return repositorySnippet;

    }

    public static List<Repository> jsonToRepositoryList(JSONObject json) throws JSONException {

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

        JSONArray rs = json.getJSONArray("datasourceInfo");

        for(int i=0;i<rs.length();i++)

            resultSet.add(jsonToRepositoryObject( rs.getJSONObject(i)) );

        return resultSet;

    }

    public static List<RepositoryInterface> jsonToRepositoryInterfaceList(JSONObject json) throws JSONException {

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

        JSONArray rs = json.getJSONArray("api");

        for(int i=0;i<rs.length();i++)

            resultSet.add(jsonToRepositoryInterfaceObject( rs.getJSONObject(i)) );

        return resultSet;

    }

    public static RepositoryInterface jsonToRepositoryInterfaceObject(JSONObject repositoryInterfaceObject) throws JSONException {

        RepositoryInterface repositoryInterface = new RepositoryInterface();

        repositoryInterface.setId(repositoryInterfaceObject.get("id").toString());

        repositoryInterface.setAccessProtocol(repositoryInterfaceObject.get("protocol").toString());

        repositoryInterface.setContentDescription(repositoryInterfaceObject.get("contentdescription").toString());

        repositoryInterface.setTypology(repositoryInterfaceObject.get("typology").toString());

        repositoryInterface.setCompliance(repositoryInterfaceObject.get("compatibility").toString());

        repositoryInterface.setLastCollectionDate(repositoryInterfaceObject.get("lastCollectionDate").toString());

        repositoryInterface.setBaseUrl(repositoryInterfaceObject.get("baseurl").toString());

        repositoryInterface.setRemovable(Boolean.parseBoolean(repositoryInterfaceObject.get("removable").toString()));

       // repositoryInterface.setMetadataIdentifierPath(repositoryInterfaceObject.get("metadataIdentifierPath").toString());

        repositoryInterface.setDesiredCompatibilityLevel(repositoryInterfaceObject.get("compatibility").toString());

        //repositoryInterface.setActive(Boolean.parseBoolean(repositoryInterfaceObject.get("active").toString()));

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

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

        ObjectMapper mapper = new ObjectMapper();

        JSONArray apiparams = repositoryInterfaceObject.getJSONArray("apiParams");

        for(int i=0;i<apiparams.length();i++)

            accessParams.put(apiparams.getJSONObject(i).getString("param"),apiparams.getJSONObject(i).getString("value"));

        repositoryInterface.setAccessParams(accessParams);

        return repositoryInterface;

    }

    public static String repositoryObjectToJson(Repository repository) throws JSONException, JsonProcessingException {

        JSONObject jsonObject = new JSONObject();

        jsonObject.put("id",repository.getId());

        jsonObject.put("openaireId",getOpenaireId(repository.getId()));

        jsonObject.put("officialname",repository.getOfficialName());

        jsonObject.put("englishname",repository.getEnglishName());

        jsonObject.put("websiteurl",repository.getWebsiteUrl());

        jsonObject.put("logourl",repository.getLogoUrl());

        jsonObject.put("contactemail",repository.getContactEmail());

        jsonObject.put("longitude",repository.getLongitude().toString());

        jsonObject.put("latitude",repository.getLatitude().toString());

        jsonObject.put("timezone",repository.getTimezone());

        jsonObject.put("namespaceprefix",repository.getNamespacePrefix()!=null?repository.getNamespacePrefix():"");

        jsonObject.put("languages",repository.getOdLanguages()!=null?repository.getOdLanguages():"");

        jsonObject.put("dateofcollection",repository.getDateOfCollection()!=null?convertDateToString(repository.getDateOfCollection()):"");

        /*

        * typology -> platform

        * datasource class -> typology

        * */

        jsonObject.put("typology",repository.getDatasourceClass());

        jsonObject.put("platform",repository.getTypology());

        jsonObject.put("dateofvalidation",repository.getDateOfCollection()!=null?convertDateToString(repository.getDateOfCollection()):"");

        jsonObject.put("activationId",repository.getActivationId()!=null?repository.getActivationId():"");

        jsonObject.put("description",repository.getDescription());

        jsonObject.put("eissn",repository.getEissn()!=null?repository.getEissn():"");

        jsonObject.put("issn",repository.getIssn()!=null?repository.getIssn():"");

        jsonObject.put("lissn",repository.getLissn()!=null?repository.getLissn():"");

        jsonObject.put("registeredby",repository.getRegisteredBy());

        jsonObject.put("aggregator",repository.getAggregator()!=null?repository.getAggregator():"");

        jsonObject.put("collectedfrom",repository.getCollectedFrom()!=null?repository.getCollectedFrom():"");

        jsonObject.put("managed",repository.isRegistered());

        JSONObject organization = new JSONObject();

        organization.put("legalname",repository.getOrganization());

        organization.put("country",repository.getCountryCode());

        organization.put("legalshortname","");

        organization.put("websiteurl","");

        organization.put("logourl","");

        JSONArray organizations = new JSONArray();

        organizations.put(organization);

        jsonObject.put("organizations",organizations);

        //TODO check identitites

        JSONArray identities = new JSONArray();

        identities.put(identities);

        jsonObject.put("identities",identities);

        //TODO check fields

       /* jsonObject.put("certificates",repository.getCertificates());

        jsonObject.put("citationguidelineurl",repository.getCitationGuidelineUrl());

        jsonObject.put("databaseaccessrestriction",repository.getDatabaseAccessRestriction());

        jsonObject.put("databaseaccesstype",repository.getDatabaseAccessType());

        jsonObject.put("datauploadrestriction",repository.getDataUploadRestriction());

        jsonObject.put("datauploadtype",repository.getDataUploadType());

        jsonObject.put("missionstatementurl",repository.getMissionStatementUrl());

        jsonObject.put("od_contenttypes",repository.getOdContentTypes());

        jsonObject.put("officialname",repository.getOfficialname());

        jsonObject.put("pidsystems",repository.getPidSystems());

        jsonObject.put("provenanceaction",repository.getProvenanceActionClass());

        jsonObject.put("qualitymanagementkind",repository.getQualityManagementKind());

        jsonObject.put("releaseenddate",convertDateToString(repository.getReleaseEndDate()));

        jsonObject.put("releasestartdate",convertDateToString(repository.getReleaseStartDate()));

        jsonObject.put("serviceprovider",repository.getServiceProvider());

        jsonObject.put("versioning",repository.getVersioning());

        //datasource.get("platform");

        //datasource.get("subjects");*/

        ObjectMapper mapper = new ObjectMapper();

        return mapper.writeValueAsString(jsonObject);

    }

    public static String repositoryInterfaceObjectToJson(Repository repository,RepositoryInterface repositoryInterface) throws JSONException {

        JSONObject jsonObject = new JSONObject();

        jsonObject.put("id",repositoryInterface.getId());

        jsonObject.put("protocol",repositoryInterface.getAccessProtocol());

        jsonObject.put("datasource",repository.getId());

        jsonObject.put("contentdescription",repositoryInterface.getContentDescription());

        jsonObject.put("typology",repositoryInterface.getTypology());

        jsonObject.put("compatibility",repositoryInterface.getDesiredCompatibilityLevel());

        jsonObject.put("compatibilityOverride",repositoryInterface.getDesiredCompatibilityLevel());

        jsonObject.put("lastCollectionTotal","");

        jsonObject.put("lastCollectionDate",repositoryInterface.getLastCollectionDate());

        jsonObject.put("lastAggregationTotal","");

        jsonObject.put("lastAggregationDate","");

        jsonObject.put("lastDownloadTotal","");

        jsonObject.put("lastDownloadDate","");

        jsonObject.put("baseurl",repositoryInterface.getBaseUrl());

        jsonObject.put("removable",repositoryInterface.isRemovable());

        JSONArray apiparams = new JSONArray();

        for(String param: repositoryInterface.getAccessParams().keySet()){

            JSONObject jo = new JSONObject();

            jo.put("param",param);

            jo.put("value",repositoryInterface.getAccessParams().get(param));

            apiparams.put(jo);

        }

        jsonObject.put("apiParams",apiparams);

//        jsonObject.put("metadataIdentifierPath",repositoryInterface.getMetadataIdentifierPath());

        return jsonObject.toString();

    }

    public static ArrayList<String> readFile(String filename) {

        String line;

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

        try {

            //InputStream in = Converter.class.getResourceAsStream("resources/eu/dnetlib/repo/manager/service/utils/"+filename);

            InputStream in = Converter.class.getClass().getResourceAsStream("/eu/**/" + filename);

            BufferedReader br = new BufferedReader(new InputStreamReader(in));

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

                list.add(line.trim());

            }

            br.close();

        } catch (IOException e) {

            LOGGER.debug("Error opening file!");

            e.printStackTrace();

        }

        return list;

    }

    public static List<AggregationDetails> getAggregationHistoryFromJson(JSONObject datasourceInfo) throws JSONException {

        JSONArray rs = new JSONArray(datasourceInfo.get("aggregationHistory").toString());

        List<AggregationDetails> aggregationDetailsList = new ArrayList<>();

        for(int i=0;i<rs.length();i++)

            aggregationDetailsList.add(jsonToAggregationDetails(rs.getJSONObject(i)));

        return aggregationDetailsList;

    }

    private static AggregationDetails jsonToAggregationDetails(JSONObject aggregationObject) throws JSONException {

        AggregationDetails aggregationDetails = new AggregationDetails();

        aggregationDetails.setAggregationStage(aggregationObject.get("aggregationStage").toString());

        if(aggregationObject.has("collectionMode"))

            aggregationDetails.setCollectionMode(aggregationObject.get("collectionMode").toString());

        if(aggregationObject.has("indexedVersion"))

            aggregationDetails.setIndexedVersion(Boolean.parseBoolean(aggregationObject.get("indexedVersion").toString()));

        aggregationDetails.setDate(convertStringToDate(aggregationObject.get("date").toString()));

        aggregationDetails.setNumberOfRecords(Integer.parseInt(aggregationObject.get("numberOfRecords").toString()));

        return aggregationDetails;

    }

    public static AggregationDetails getLastCollectionFromJson(JSONObject datasourceInfo) throws JSONException {

        if( datasourceInfo.get("lastCollection").equals(null))

            return null;

        return jsonToAggregationDetails(datasourceInfo.getJSONObject("lastCollection"));

    }

    public static AggregationDetails getLastTransformationFromJson(JSONObject datasourceInfo) throws JSONException {

        if( datasourceInfo.get("lastTransformation").equals(null))

            return null;

        return jsonToAggregationDetails(datasourceInfo.getJSONObject("lastTransformation"));

    }

    public static List<Timezone> toTimezones(List<String> timezones) {

        List<Timezone> tmz = new ArrayList<>();

        for(String t : timezones){

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

            tmz.add(new Timezone(s[1],Double.parseDouble(s[0])));

        }

        return tmz;

    }

    public static String getOpenaireId(String repositoryId) {

        if (repositoryId != null && repositoryId.contains("::"))

            return repositoryId.split("::")[0] + "::" + DigestUtils.md5Hex(repositoryId.split("::")[1]);

        return null;

    }

}

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

import org.apache.log4j.Logger;

import org.dom4j.io.DOMWriter;

import org.w3c.dom.Document;

import se.kb.oai.pmh.*;

import se.kb.oai.pmh.Set;

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

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 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.service.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.config;

import com.nimbusds.jwt.JWT;

import org.mitre.openid.connect.client.OIDCAuthoritiesMapper;

import org.mitre.openid.connect.model.UserInfo;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.authority.SimpleGrantedAuthority;

import java.util.*;

public class OpenAireProviderAuthoritiesMapper implements OIDCAuthoritiesMapper {

    private static Logger logger = LoggerFactory.getLogger(OpenAireProviderAuthoritiesMapper.class);

    final private static String ROLE_CLAIMS = "edu_person_entitlements";

    private Map<String,SimpleGrantedAuthority> userRolesMap;

    OpenAireProviderAuthoritiesMapper(Map<String,String> userRoles) {

        userRolesMap = new HashMap<>();

        userRoles.forEach((openaireRole, appRole) -> userRolesMap.put(openaireRole, new SimpleGrantedAuthority(appRole)));

    }

    @Override

    public Collection<? extends GrantedAuthority> mapAuthorities(JWT idToken, UserInfo userInfo) {

        Set<GrantedAuthority> out = new HashSet<>();

        out.add(new SimpleGrantedAuthority("ROLE_USER"));

        if(userInfo.getSource().getAsJsonArray(ROLE_CLAIMS) != null) {

            userInfo.getSource().getAsJsonArray(ROLE_CLAIMS).forEach(role -> {

                SimpleGrantedAuthority authority = userRolesMap.get(role.getAsString());

                if (authority != null) {

                    logger.debug("Role mapped " + role);

                    out.add(authority);

                }

            });

        }

        return out;

    }

}

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

import com.google.gson.JsonObject;

import org.apache.log4j.Logger;

import org.mitre.openid.connect.model.OIDCAuthenticationToken;

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

import org.springframework.security.core.Authentication;

import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import javax.servlet.ServletException;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

import java.net.URLEncoder;

import com.google.gson.*;

public class FrontEndLinkURIAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

    private String frontEndURI;

    private static final Logger LOGGER = Logger

            .getLogger(FrontEndLinkURIAuthenticationSuccessHandler.class);

    public void init(){

        LOGGER.debug("Front end uri : " + frontEndURI);

    }

    @Value("${aai.mode}")

    private String aai_mode;

    @Override

    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {

        OIDCAuthenticationToken authOIDC = (OIDCAuthenticationToken) authentication;

        JsonObject userInfo = new JsonObject();

        if (authOIDC.getUserInfo().getSub() == null)

            userInfo.addProperty("sub", "");

        else

            userInfo.addProperty("sub", URLEncoder.encode(authOIDC.getUserInfo().getSub(), "UTF-8"));

        if(authOIDC.getUserInfo().getName() != null)

            userInfo.addProperty("fullname", URLEncoder.encode(authOIDC.getUserInfo().getName(), "UTF-8"));

        if (authOIDC.getUserInfo().getGivenName() == null)

            userInfo.addProperty("firstname", "");

        else

            userInfo.addProperty("firstname", URLEncoder.encode(authOIDC.getUserInfo().getGivenName(), "UTF-8") + "");

        if (authOIDC.getUserInfo().getFamilyName() == null)

            userInfo.addProperty("lastname",  "");

        else

            userInfo.addProperty("lastname", URLEncoder.encode(authOIDC.getUserInfo().getFamilyName(), "UTF-8") + "");

        userInfo.addProperty("email", authOIDC.getUserInfo().getEmail() + "");

        if (authOIDC.getUserInfo().getSource().getAsJsonArray("edu_person_entitlements") == null)

            userInfo.addProperty("role",  "");

        else

            userInfo.addProperty("role", URLEncoder.encode(authOIDC.getUserInfo()

                    .getSource().getAsJsonArray("edu_person_entitlements").toString(), "UTF-8") + "");

        Cookie openAIREUser = new Cookie("openAIREUser", new Gson().toJson(userInfo) );

        openAIREUser.setMaxAge(14400);

        openAIREUser.setPath("/");

        if(aai_mode.equalsIgnoreCase("production") || aai_mode.equalsIgnoreCase("beta"))

            openAIREUser .setDomain(".openaire.eu");

//        openAIREUser.setDomain(".athenarc.gr");

        response.addCookie(openAIREUser);

        Cookie accessToken = new Cookie("AccessToken", authOIDC.getAccessTokenValue());

        accessToken.setMaxAge(14400);

        if(aai_mode.equalsIgnoreCase("production") || aai_mode.equalsIgnoreCase("beta"))

            accessToken.setDomain(".openaire.eu");

        accessToken.setPath("/");

//        accessToken.setDomain(".athenarc.gr");

        response.addCookie(accessToken);

        response.sendRedirect(frontEndURI);

    }

    public String getFrontEndURI() {

        return frontEndURI;

    }

    public void setFrontEndURI(String frontEndURI) {

        this.frontEndURI = frontEndURI;

    }

}

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

import org.apache.log4j.Logger;

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

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.PropertySource;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

import org.springframework.session.web.http.CookieSerializer;

import org.springframework.session.web.http.DefaultCookieSerializer;

import javax.annotation.PostConstruct;

@Configuration

@EnableRedisHttpSession

@PropertySource(value = {"classpath:application.properties"} )

@ComponentScan(basePackages = "eu.dnetlib.repo.manager.service.controllers")

public class Config {

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

    @Value("${redis.host:194.177.192.121}")

    private String host;

    @Value("${redis.port:6379}")

    private String port;

    @Value("${redis.password}")

    private String password;

    @Value("${aai.mode}")

    private String aai_mode;

    @PostConstruct

    private void init(){

        LOGGER.info(host);

    }

    @Bean

    JedisConnectionFactory connectionFactory() {

        LOGGER.info(String.format("Redis : %s Port : %s Password : %s",host,port,password));

        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();

        jedisConnectionFactory.setHostName(host);

        jedisConnectionFactory.setPort(Integer.parseInt(port));

        if(password != null) jedisConnectionFactory.setPassword(password);

        return jedisConnectionFactory;

    }

    @Bean

    public CookieSerializer cookieSerializer() {

        DefaultCookieSerializer serializer = new DefaultCookieSerializer();

        serializer.setCookieName("openAIRESession");

        serializer.setCookiePath("/");

        if(aai_mode.equalsIgnoreCase("production") || aai_mode.equalsIgnoreCase("beta"))

            serializer.setDomainName(".openaire.eu");

//        serializer.setDomainName(".athenarc.gr");

        LOGGER.info("Serializer : " + serializer);

        return serializer;

    }

}

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

import eu.dnetlib.repo.manager.service.controllers.MonitorApi;

import eu.dnetlib.repo.manager.service.controllers.PiWikApi;

import eu.dnetlib.repo.manager.service.controllers.RepositoryApi;

import eu.dnetlib.repo.manager.service.controllers.ValidatorApi;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import springfox.documentation.builders.PathSelectors;

import springfox.documentation.builders.RequestHandlerSelectors;

import springfox.documentation.service.ApiInfo;

import springfox.documentation.service.Contact;

import springfox.documentation.service.VendorExtension;

import springfox.documentation.spi.DocumentationType;

import springfox.documentation.spring.web.plugins.Docket;

import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;

/**

 * Created by panagiotis on 16/11/2017.

 */

@Configuration

@EnableSwagger2

@EnableWebMvc

@ComponentScan(basePackageClasses = {

        RepositoryApi.class,

        MonitorApi.class,

        ValidatorApi.class,

        PiWikApi.class

})

public class SwaggerConfig  {

    @Bean

    public Docket productApi() {

        return new Docket(DocumentationType.SWAGGER_2)

                .select()

                .apis(RequestHandlerSelectors.any())

                .paths(PathSelectors.any())

                .build()

                .pathMapping("/")

                .apiInfo(getApiInfo());

    }

    private ApiInfo getApiInfo() {

        return new ApiInfo("Repository Manager Dashboard API Documentation",

                "Repository Manager Dashboard API Documentation",

                "1.0",

                "urn:tos",

                new Contact("", "", ""),

                "Apache 2.0", "http://www.apache.org/licenses/LICENSE-2.0",

                new ArrayList<VendorExtension>());

    }

}

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

import eu.dnetlib.domain.data.PiwikInfo;

import eu.dnetlib.domain.data.Repository;

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

import org.springframework.security.core.Authentication;

public interface EmailUtils {

    void reportException(Exception exception);

    void sendAdministratorRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendUserRequestToEnableMetrics(PiwikInfo piwikInfo) throws Exception;

    void sendAdministratorMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendUserMetricsEnabled(PiwikInfo piwikInfo) throws Exception;

    void sendUserRegistrationEmail(Repository repository, Authentication authentication) throws Exception;

    void sendUserUpdateRepositoryEmail(Repository repository, Authentication authentication) throws Exception;

    void sendSubmitJobForValidationEmail(Authentication authentication, JobForValidation jobForValidation) throws Exception;

}

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

import io.swagger.annotations.Api;

import org.springframework.http.ResponseEntity;

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

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

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

@RestController

@RequestMapping(value = "/user")

@Api(description = "User API",  tags = {"user"})

public interface UserApi {

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

    ResponseEntity<Object> login();

}

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

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

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

import eu.dnetlib.repo.manager.service.exception.ResourceNotFoundException;

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

import io.swagger.annotations.Api;

import org.json.JSONException;

import org.springframework.http.MediaType;

import org.springframework.security.core.Authentication;

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

import java.io.IOException;

import java.util.List;

import java.util.Map;

@RestController

@RequestMapping(value = "/repository")

@Api(description = "Repository API",  tags = {"repository"})

public interface RepositoryApi {

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

    @ResponseBody

    Country[] getCountries() ;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<RepositorySnippet> getRepositoriesByCountry(String country, String mode, Boolean managed) throws JSONException, IOException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<Repository> getRepositoriesOfUser(String userEmail,

                                           String page,

                                           String size) throws JSONException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Repository getRepositoryById(String id) throws JSONException, ResourceNotFoundException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<AggregationDetails> getRepositoryAggregations(String id) throws JSONException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Map<String,List<AggregationDetails>> getRepositoryAggregationsByYear(String id) throws JSONException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<Repository> getRepositoriesByName(String name,

                                           String page,

                                           String size) throws JSONException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<RepositoryInterface> getRepositoryInterface(String id) throws JSONException;

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

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Repository addRepository(String datatype, Repository repository) throws Exception;

    @RequestMapping(value = "/deleteInterface/", method = RequestMethod.DELETE)

    void deleteRepositoryInterface(String id,String registeredBy);

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

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    RepositoryInterface addRepositoryInterface(String datatype,

                                               String repoId,

                                               String registeredBy,

                                               RepositoryInterface iFace) throws JSONException,ResourceNotFoundException;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<String> getDnetCountries();

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<String> getTypologies();

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<Timezone> getTimezones();

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

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Repository updateRepository(Repository repository, Authentication authentication) throws Exception;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<String> getUrlsOfUserRepos(String user_email,

                                    String page,

                                    String size) throws JSONException;

    @RequestMapping(value = "/getDatasourceVocabularies/{mode}",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    List<String> getDatasourceVocabularies(String mode);

    @RequestMapping(value = "/getCompatibilityClasses/{mode}",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Map<String, String> getCompatibilityClasses(String mode);

    @RequestMapping(value = "/getDatasourceClasses/{mode}",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Map<String, String> getDatasourceClasses(String mode);

    String getCountryName(String countryCode);

    @RequestMapping(value = "/getMetricsInfoForRepository/{repoId}",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    MetricsInfo getMetricsInfoForRepository(String repoId) throws RepositoryServiceException;

    @RequestMapping(value = "/getListLatestUpdate/{mode}",method = RequestMethod.GET,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    Map<String, String> getListLatestUpdate(String mode) throws RepositoryServiceException, JSONException;

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

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    RepositoryInterface updateRepositoryInterface(String repositoryId,String registeredBy,RepositoryInterface repositoryInterface) throws JSONException;

}

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

import com.mongodb.util.JSON;

import org.apache.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

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

import org.springframework.http.HttpHeaders;

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

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import javax.annotation.PostConstruct;

import java.util.HashMap;

import java.util.Map;

@Component

public class StatsApiImpl implements StatsApi {

    private RestTemplate restTemplate = null;

    private HttpHeaders httpHeaders;

    private static final Logger LOGGER = Logger.getLogger(RepositoryApiImpl.class);

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

    private String baseAddress;

    @Value("${search.api.usagestats}")

    private String usagestatsBaseAddress;

    @Value("${search.api.usageEvents}")

    private String usagestatsEvents;

    @PostConstruct

    private void init() {

        LOGGER.debug("Initialization method of statistics api!");

        restTemplate = new RestTemplate();

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

        httpHeaders = new HttpHeaders();

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

    }

    @Override

    public Map<String, Object> getStatistics() throws JSONException {

        String aggregators = getTotalByType("datasource",baseAddress+"/resources",

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository Aggregator " +

                "     or datasourcetypename exact Publication Repository Aggregator )");

        String dataRepositories = getTotalByType("datasource",baseAddress+"/resources",

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Data Repository " );

        String literature = getTotalByType("datasource",baseAddress+"/resources",

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository  " +

                "     or datasourcetypename exact Publication Repository )");

        String journal = getTotalByType("datasource",baseAddress+"/resources",

                "?query= " +

                " oaftype exact datasource and " +

                " datasourcetypename exact Journal");

        String publications = getTotalByType("other",baseAddress,"/publications/count");

        String datasets = getTotalByType("other",baseAddress,"/datasets/count");

        String software = getTotalByType("other",baseAddress,"/software/count");

        JSONObject lastYearUsagestats = getLastYearUsageStatsTotal();

        Integer usagestats = getUsageStatsTotal();

        HashMap<String,Object> stats = new HashMap<>();

        stats.put("aggregators",aggregators);

        stats.put("dataRepositories",dataRepositories);

        stats.put("literature",literature);

        stats.put("journal",journal);

        stats.put("publications",publications);

        stats.put("datasets",datasets);

        stats.put("software",software);

        stats.put("lastYearUsagestats",lastYearUsagestats.toString());

        stats.put("usagestats",usagestats.toString());

        return stats;

    }

    private String getTotalByType(String type,String url,String query) throws JSONException {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url + query)

                .queryParam("page",0)

                .queryParam("size",0)

                .queryParam("format","json")

                .build().encode();

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

        if(type.equalsIgnoreCase("datasource")){

            JSONObject metadata = (JSONObject) new JSONObject(rs).get("meta");

            return String.valueOf(metadata.get("total"));

        }else

            return String.valueOf(new JSONObject(rs).get("total"));

    }

    private JSONObject getLastYearUsageStatsTotal() throws JSONException {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsBaseAddress + "/totals")

                .build().encode();

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

        JSONArray resultSet = (JSONArray) new JSONObject(rs).getJSONArray("yearly_stats");

        JSONObject lastYear = resultSet.getJSONObject(resultSet.length()-1);

        Integer downloads = lastYear.getInt("downloads");

        Integer views = lastYear.getInt("views");

        String year = lastYear.getString("year");

        JSONObject usagestats = new JSONObject();

        usagestats.put("number",String.valueOf(downloads+views));

        usagestats.put("year",year);

        return usagestats;

    }

    private Integer getUsageStatsTotal() throws JSONException {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsEvents)

                .build().encode();

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

        JSONObject resultSet = new JSONObject(rs);

        JSONObject totals = resultSet.getJSONObject("totals");

        return Integer.valueOf(totals.getString("events"));

    }

}

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

import eu.dnetlib.domain.data.PiwikInfo;

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

import io.swagger.annotations.Api;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

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

import java.util.List;

@RestController

@RequestMapping(value = "/piwik")

@Api(description = "Piwik API",  tags = {"piwik"})

public interface PiWikApi {

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

    @ResponseBody

    PiwikInfo getPiwikSiteForRepo(String repositoryId);

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

    PiwikInfo savePiwikInfo( PiwikInfo piwikInfo);

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

    List<PiwikInfo> getPiwikSitesForRepos();

    @RequestMapping(value = "/approvePiwikSite/{repositoryId}" , method = RequestMethod.GET)

    @ResponseBody

    ResponseEntity<Object> approvePiwikSite(String repositoryId);