D-Net

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

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class LastYearUsageStatsHystrixCommand extends HystrixCommand<Map> {

    RestTemplate restTemplate;

    String usagestatsBaseAddress;

    public LastYearUsageStatsHystrixCommand(String usagestatsBaseAddress,RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.usagestatsBaseAddress = usagestatsBaseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected Map run() throws Exception {

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(usagestatsBaseAddress + "/totals")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET,null,Map.class);

        List yearly_stats = (List) ((Map)rs.getBody()).get("yearly_stats");

        Map lastYear = (Map) yearly_stats.get(yearly_stats.size()-1);

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

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

        Integer year = (Integer) lastYear.get("year");

        Map<String,Object> usagestats = new HashMap<>();

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

        usagestats.put("year",year);

        return usagestats;

    }

    @Override

    protected Map getFallback() {

        return null;

    }

}

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

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class SoftwareHystrixCommand extends HystrixCommand<String> {

    String baseAddress;

    RestTemplate restTemplate;

    public SoftwareHystrixCommand(String baseAddress, RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() {

        String url = baseAddress + "/software/count";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) (rs.getBody());

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

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.utils;

import org.apache.log4j.Logger;

import org.dom4j.io.DOMWriter;

import org.w3c.dom.Document;

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

import com.netflix.hystrix.HystrixCommand;

import com.netflix.hystrix.HystrixCommandGroupKey;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.util.UriComponents;

import org.springframework.web.util.UriComponentsBuilder;

import java.util.Map;

public class LiteratureHystrixCommand extends HystrixCommand<String> {

    RestTemplate restTemplate;

    private String baseAddress;

    public LiteratureHystrixCommand(String baseAddress , RestTemplate restTemplate) {

        super(HystrixCommandGroupKey.Factory.asKey("StatisticsGroup"));

        this.baseAddress = baseAddress;

        this.restTemplate = restTemplate;

    }

    @Override

    protected String run() throws Exception {

        String url = baseAddress+"/resources"+

                "?query= " +

                " oaftype exact datasource and " +

                " ( datasourcetypename exact Institutional Repository  " +

                "     or datasourcetypename exact Publication Repository )";

        UriComponents uriComponents = UriComponentsBuilder

                .fromHttpUrl(url)

                .queryParam("page", 0)

                .queryParam("size", 0)

                .queryParam("format", "json")

                .build().encode();

        ResponseEntity rs = restTemplate.exchange(uriComponents.toUri(), HttpMethod.GET, null, Map.class);

        Map metadata = (Map) ((Map) rs.getBody()).get("meta");

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

    }

    @Override

    protected String getFallback() {

        return null;

    }

}

package eu.dnetlib.repo.manager.service;

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

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

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Service("userService")

public class UserServiceImpl implements UserService {

    private static final org.apache.log4j.Logger LOGGER = org.apache.log4j.Logger

            .getLogger(UserServiceImpl.class);

    @Value("${oidc.issuer}")

    private String oidc_issuer;

    @Override

    public ResponseEntity<Object> login() {

        OIDCAuthenticationToken authentication = (OIDCAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();

        LOGGER.debug("User authentication : " + authentication);

        Map<String,Object> body = new HashMap<>();

        body.put("sub",authentication.getSub());

        if(authentication.getUserInfo().getName() == null || authentication.getUserInfo().getName().equals(""))

            body.put("name",authentication.getUserInfo().getGivenName() + " " + authentication.getUserInfo().getFamilyName());

        else

            body.put("name",authentication.getUserInfo().getName());

        body.put("email",authentication.getUserInfo().getEmail());

        List<String> roles = authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());

        body.put("role",roles);

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

    }

}

package eu.dnetlib.repo.manager.config;

import com.google.gson.Gson;

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;

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;

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

               http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:annotation-config/>

    <context:component-scan base-package="eu.dnetlib.repo.manager.service.*"/>

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

          id="propertyLoader">

        <property name="order" value="2"/>

        <property name="properties">

            <bean class="eu.dnetlib.conf.WebappContextProperyFactory">

                <property name="propertyFetcher">

                    <bean class="eu.dnetlib.conf.PropertyFetcher"/>

                </property>

            </bean>

        </property>

        <property name="ignoreUnresolvablePlaceholders" value="true"/>

        <property name="locations">

            <list>

                <value>classpath*:/gr/**/springContext-*.properties</value>

                <value>classpath*:/eu/**/springContext-*.properties</value>

                <value>classpath*:/application.properties</value>

                <value>classpath*:/email-texts.properties</value>

<!--                <value>classpath*:dnet-site-wizard.properties</value>-->

<!--                <value>classpath*:dnet-site-override.properties</value>-->

<!--                <value>classpath*:dnet-wizard.properties</value>-->

<!--                <value>classpath*:dnet-override-new.properties</value>-->

<!--                <value>classpath*:dnet-validator-wizard.properties</value>-->

<!--                <value>classpath*:dnet-validator-override.properties</value>-->

<!--                <value>classpath*:dnet-site-force-override.properties</value>-->

<!--                <value>classpath*:dnet-force-override.properties</value>-->

            </list>

        </property>

    </bean>

</beans>

package eu.dnetlib.repo.manager.controllers;

import eu.dnetlib.repo.manager.service.StatsServiceImpl;

import io.swagger.annotations.Api;

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

import org.springframework.http.MediaType;

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

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

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

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

import java.util.Map;

@RestController

@RequestMapping(value = "/stats")

@Api(description = "Stats API",  tags = {"statistics"})

public class StatsController {

    @Autowired

    private StatsServiceImpl statsService;

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

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    public Map getStatistics(){

       return statsService.getStatistics();

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <import resource="classpath*:/application-context.xml"/>

    <import resource="classpath*:/eu/dnetlib/soap/cxf/applicationContext-eprbuilders.xml"/>

    <import resource="classpath*:/eu/dnetlib/clients/ws/springContext-locatorFactory.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/util/springContext-locators.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-lookupFactory.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-lookupClients.xml"/>

    <import resource="classpath*:/eu/dnetlib/enabling/hcm/springContext-hcmService.xml"/>

    <import resource="classpath*:/gr/uoa/di/driver/app/springContext-commons.xml"/>

    <!--<import resource="classpath*:/gr/uoa/di/driver/app/springContext-registrator.xml"/>-->

    <bean id="maillib" class="eu.dnetlib.utils.MailLibrary" init-method="init">

        <property name="mailhost" value="${services.validator.mail.host}"/>

        <property name="smtpPort" value="${services.validator.mail.port}"/>

        <property name="authenticate" value="${services.validator.mail.authenticate}"/>

        <property name="username" value="${services.validator.mail.username}"/>

        <property name="password" value="${services.validator.mail.password}"/>

        <property name="from" value="${services.validator.mail.fromAddress}"/>

        <property name="replyTo" value="${services.validator.mail.replyToAddress}"/>

        <property name="mode" value="${services.validator.mail.mode}"/>

        <property name="debug" value="${services.validator.mail.debug}"/>

    </bean>

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

          id="propertyLoader">

        <property name="order" value="2"/>

        <property name="properties">

            <bean class="eu.dnetlib.conf.WebappContextProperyFactory">

                <property name="propertyFetcher">

                    <bean class="eu.dnetlib.conf.PropertyFetcher"/>

                </property>

            </bean>

        </property>

        <property name="ignoreUnresolvablePlaceholders" value="true"/>

        <property name="locations">

            <list>

                <value>classpath*:/gr/**/springContext-*.properties</value>

                <value>classpath*:/eu/**/springContext-*.properties</value>

                <value>classpath*:/application.properties</value>

                <value>classpath*:/email-texts.properties</value>

<!--                <value>classpath*:dnet-site-wizard.properties</value>-->

<!--                <value>classpath*:dnet-site-override.properties</value>-->

<!--                <value>classpath*:dnet-wizard.properties</value>-->

<!--                <value>classpath*:dnet-override-new.properties</value>-->

<!--                <value>classpath*:dnet-validator-wizard.properties</value>-->

<!--                <value>classpath*:dnet-validator-override.properties</value>-->

<!--                <value>classpath*:dnet-site-force-override.properties</value>-->

<!--                <value>classpath*:dnet-force-override.properties</value>-->

            </list>

        </property>

    </bean>

    <bean id="repomanager.dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${repomanager.db.driverClassName}" />

        <property name="url" value="${repomanager.db.url}" />

        <property name="username" value="${repomanager.db.username}" />

        <property name="password" value="${repomanager.db.password}" />

        <property name="maxIdle" value="10" />

        <property name="maxActive" value="100" />

        <property name="maxWait" value="10000" />

        <property name="validationQuery" value="SELECT 1;" />

        <property name="testOnBorrow" value="true" />

        <property name="testOnReturn" value="true" />

        <property name="testWhileIdle" value="true" />

        <property name="timeBetweenEvictionRunsMillis" value="1200000" />

        <property name="minEvictableIdleTimeMillis" value="1800000" />

        <property name="numTestsPerEvictionRun" value="5" />

        <property name="poolPreparedStatements" value="true" />

        <property name="defaultAutoCommit" value="true" />

    </bean>

    <tx:annotation-driven transaction-manager="txManager"/>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="repomanager.dataSource"/>

    </bean>

    <mvc:resources mapping="swagger-ui.html" location="classpath:/META-INF/resources/"/>

    <mvc:resources mapping="/webjars/**" location="classpath:/META-INF/resources/webjars/"/>

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

</beans>

package eu.dnetlib.repo.manager.config;

import org.mitre.oauth2.model.ClientDetailsEntity.AuthMethod;

import org.mitre.oauth2.model.RegisteredClient;

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

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

import org.mitre.openid.connect.client.service.impl.*;

import org.mitre.openid.connect.config.ServerConfiguration;

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

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

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

import org.springframework.security.web.authentication.preauth.AbstractPreAuthenticatedProcessingFilter;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

@Configuration

@EnableWebSecurity

public class AaiSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Value("${webapp.dev.front}")

    private String logoutSuccessUrl;

    @Value("${oidc.issuer}")

    private String oidcIssuer;

    @Value("${oidc.id}")

    private String oidcId;

    @Value("${oidc.secret}")

    private String oidcSecret;

    @Value("${oidc.dev.home}")

    private String oidcDevHome;

    @Value("${webapp.dev.front}")

    private String webAppFrontEnd;

    private Map<String, String> userRoles = new HashMap<String, String>(){{

        put("urn:geant:openaire.eu:group:Super+Administrator#aai.openaire.eu", "ROLE_ADMIN");

        put("urn:geant:openaire.eu:group:Content+Provider+Dashboard+Administrator#aai.openaire.eu","ROLE_PROVIDE_ADMIN");

    }};

    @Bean

    @Override

    public AuthenticationManager authenticationManagerBean() throws Exception {

        return authenticationManager();

    }

    @Override

    protected void configure(AuthenticationManagerBuilder auth) throws Exception {

        auth.authenticationProvider(openIdConnectAuthenticationProvider());

    }

    @Override

    protected void configure(HttpSecurity http) throws Exception {

        http.csrf().disable()

                .anonymous().disable()

                .authorizeRequests()

                .anyRequest().authenticated()

                .and()

                    .httpBasic()

                    .authenticationEntryPoint(authenticationEntryPoint())

                .and()

                    .logout().logoutUrl("/openid_logout")

                    .invalidateHttpSession(true)

                    .deleteCookies("openAIRESession")

                    .logoutSuccessUrl(logoutSuccessUrl)

                .and()

                    .addFilterBefore(openIdConnectAuthenticationFilter(), AbstractPreAuthenticatedProcessingFilter.class)

        ;

    }

    @Bean

    public OIDCAuthenticationProvider openIdConnectAuthenticationProvider(){

        OIDCAuthenticationProvider oidcProvider = new OIDCAuthenticationProvider();

        oidcProvider.setAuthoritiesMapper(authoritiesMapper());

        return oidcProvider;

    }

    @Bean

    public OpenAireProviderAuthoritiesMapper authoritiesMapper(){

        OpenAireProviderAuthoritiesMapper authoritiesMapper = new OpenAireProviderAuthoritiesMapper(userRoles);

        return authoritiesMapper;

    }

    @Bean

    public StaticServerConfigurationService staticServerConfigurationService(){

        StaticServerConfigurationService staticServerConfigurationService = new StaticServerConfigurationService();

        Map<String, ServerConfiguration> servers = new HashMap<>();

        servers.put(oidcIssuer, serverConfiguration());

        staticServerConfigurationService.setServers(servers);

        return staticServerConfigurationService;

    }

    @Bean

    public StaticClientConfigurationService staticClientConfigurationService(){

        StaticClientConfigurationService staticClientConfigurationService = new StaticClientConfigurationService();

        Map<String, RegisteredClient> clients = new HashMap<>();

        clients.put(oidcIssuer,registeredClient());

        staticClientConfigurationService.setClients(clients);

        return staticClientConfigurationService;

    }

    @Bean

    public RegisteredClient registeredClient(){

        RegisteredClient registeredClient = new RegisteredClient();

        registeredClient.setClientId(oidcId);

        registeredClient.setClientSecret(oidcSecret);

        registeredClient.setScope(new HashSet<>(Collections.singletonList("openid")));

        registeredClient.setTokenEndpointAuthMethod(AuthMethod.SECRET_BASIC);

        registeredClient.setRedirectUris(new HashSet<>(Collections.singletonList(oidcDevHome)));

        return registeredClient;

    }

    @Bean

    public StaticAuthRequestOptionsService staticAuthRequestOptionsService(){

        return new StaticAuthRequestOptionsService();

    }

    @Bean

    public PlainAuthRequestUrlBuilder plainAuthRequestUrlBuilder(){

        return new PlainAuthRequestUrlBuilder();

    }

    @Bean

    public ServerConfiguration serverConfiguration(){

        ServerConfiguration serverConfiguration = new ServerConfiguration();

        serverConfiguration.setIssuer(oidcIssuer);

        serverConfiguration.setAuthorizationEndpointUri(oidcIssuer+"authorize");

        serverConfiguration.setTokenEndpointUri(oidcIssuer+"token");

        serverConfiguration.setUserInfoUri(oidcIssuer+"userinfo");

        serverConfiguration.setJwksUri(oidcIssuer+"jwk");

        serverConfiguration.setRevocationEndpointUri(oidcIssuer+"revoke");

        return serverConfiguration;

    }

    @Bean

    public LoginUrlAuthenticationEntryPoint authenticationEntryPoint(){

        return new LoginUrlAuthenticationEntryPoint("/openid_connect_login");

    }

    @Bean

    public OIDCAuthenticationFilter openIdConnectAuthenticationFilter() throws Exception {

        OIDCAuthenticationFilter oidc = new OIDCAuthenticationFilter();

        oidc.setAuthenticationManager(authenticationManagerBean());

        oidc.setIssuerService(staticSingleIssuerService());

        oidc.setServerConfigurationService(staticServerConfigurationService());

        oidc.setClientConfigurationService(staticClientConfigurationService());

        oidc.setAuthRequestOptionsService(staticAuthRequestOptionsService());

        oidc.setAuthRequestUrlBuilder(plainAuthRequestUrlBuilder());

        oidc.setAuthenticationSuccessHandler(frontEndRedirect());

        return oidc;

    }

    @Bean

    public StaticSingleIssuerService staticSingleIssuerService(){

        StaticSingleIssuerService staticSingleIssuerService = new StaticSingleIssuerService();

        staticSingleIssuerService.setIssuer(oidcIssuer);

        return staticSingleIssuerService;

    }

    @Bean(initMethod = "init")

    public FrontEndLinkURIAuthenticationSuccessHandler frontEndRedirect(){

        FrontEndLinkURIAuthenticationSuccessHandler frontEnd = new FrontEndLinkURIAuthenticationSuccessHandler();

        frontEnd.setFrontEndURI(webAppFrontEnd);

        return frontEnd;

    }

}

//package unitest;

//

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

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

//import org.junit.Test;

//import org.junit.runner.RunWith;

//import org.springframework.test.context.ContextConfiguration;

//import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//

//@RunWith(SpringJUnit4ClassRunner.class)

//@ContextConfiguration(classes = RepoManagerContextLoaderListener.class)

////@WebAppConfiguration

//public class ValidatorTest {

//

//

//    @Test

//    public void identiFy(){

//

//        String url = "https://repozitorij.srce.unizg.hr/oai";

//

//

//        System.out.println("Identify repository with url : " + url);

//        try {

//            System.out.println(OaiTools.identifyRepository(url));

//        } catch (Exception e) {

//            System.out.println(e);

//        }

//    }

//

//

//}

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

import com.fasterxml.jackson.databind.ObjectMapper;

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

import org.apache.commons.lang.StringEscapeUtils;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.net.URL;

import java.net.URLEncoder;

import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = RepoManagerContextLoaderListener.class)

public class PiwikTest {

    String analyticsURL = "https://analytics.openaire.eu/addsite.php?";

    @Test

    public void enableMetricsRepo1(){

        String officialName = "BỘ SƯU TẬP SỐ";

        String repoWebsite = "http://www.vnulib.edu.vn:8000/dspace/";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    @Test

    public void enableMetricsRepo2(){

        String officialName = "ILC4CLARIN repository of language resources and tools";

        String repoWebsite = "https://dspace-clarin-it.ilc.cnr.it/repository/xmlui";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    @Test

    public void enableMetricsRepo3(){

        String officialName = "ANSTO Publications Online";

        String repoWebsite = "http://apo.ansto.gov.au/dspace/";

        enableMetrics(officialName, repoWebsite, analyticsURL);

    }

    private void enableMetrics(String officialName, String repoWebsite, String analyticsURL) {

        String url;

        try {

            url = analyticsURL + "siteName=" + URLEncoder.encode(officialName, "UTF-8") + "&url="

                    + URLEncoder.encode(repoWebsite, "UTF-8");

            url = StringEscapeUtils.escapeJava(url);

            Map map = null;

            String siteId = null;

            URL u = new URL(url);

            map = new ObjectMapper().readValue(u, Map.class);

            if(map.get("value")!=null) {

                siteId = map.get("value").toString();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}*/

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.api.functionality.ValidatorServiceException;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

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

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

import org.json.JSONException;

import org.springframework.security.core.Authentication;

import java.io.IOException;

import java.util.List;

import java.util.Map;

public interface RepositoryService {

    Country[] getCountries() ;

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

    List<Repository> getRepositoriesOfUser(String userEmail,

                                           String page,

                                           String size) throws JSONException, IOException;

    List<RepositorySnippet> getRepositoriesSnippetOfUser(String userEmail, String page, String size) throws IOException, JSONException;

    Repository getRepositoryById(String id) throws JSONException, ResourceNotFoundException;

    List<AggregationDetails> getRepositoryAggregations(String id, int from, int size) throws JSONException;

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

    List<Repository> getRepositoriesByName(String name,

                                           String page,

                                           String size) throws JSONException;

    List<RepositorySnippet> searchRegisteredRepositories(String country, String typology, String englishName,

                                                                String officialName, String requestSortBy, String order,

                                                                int page, int pageSize) throws Exception;

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

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

    void deleteRepositoryInterface(String id, String registeredBy);

    RepositoryInterface addRepositoryInterface(String datatype,

                                               String repoId,

                                               String registeredBy,

                                               RepositoryInterface iFace) throws JSONException, ResourceNotFoundException, ValidatorServiceException;

    List<String> getDnetCountries();

    List<String> getTypologies();

    List<Timezone> getTimezones();

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

    List<String> getUrlsOfUserRepos(String user_email,

                                    String page,

                                    String size) throws JSONException;

    List<String> getDatasourceVocabularies(String mode);

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

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

    String getCountryName(String countryCode);

    MetricsInfo getMetricsInfoForRepository(String repoId) throws RepositoryServiceException;

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

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

}

package eu.dnetlib.repo.manager.controllers;

import eu.dnetlib.api.functionality.ValidatorServiceException;

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

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

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

import eu.dnetlib.repo.manager.domain.InterfaceInformation;

import eu.dnetlib.repo.manager.domain.ValidationServiceException;

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

import eu.dnetlib.repo.manager.service.EmailUtils;

import eu.dnetlib.repo.manager.service.ValidatorServiceImpl;

import io.swagger.annotations.Api;

import io.swagger.annotations.ApiParam;

import org.json.JSONException;

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

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.security.access.prepost.PreAuthorize;

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

import java.util.List;

@RestController

@RequestMapping(value = "/validator")

@Api(description = "Validator API",  tags = {"validator"})

public class ValidatorController {

    @Autowired

    private ValidatorServiceImpl validatorService;

    @Autowired

    private EmailUtils emailUtils;

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

            consumes = MediaType.APPLICATION_JSON_VALUE,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    @PreAuthorize("hasRole('ROLE_USER') and #jobForValidation.userEmail == authentication.userInfo.email")

    public JobForValidation submitJobForValidation(@RequestBody JobForValidation jobForValidation) throws ValidatorServiceException {

        return validatorService.submitJobForValidation(jobForValidation);

    }

    @RequestMapping(value = "/reSubmitJobForValidation/{email}/{jobId}",method = RequestMethod.POST,

            consumes = MediaType.APPLICATION_JSON_VALUE,

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    @PreAuthorize("hasRole('ROLE_USER') and #email == authentication.userInfo.email")

    public ResponseEntity<Object> reSubmitJobForValidation(@PathVariable("email") String email,

                                                           @PathVariable("jobId") String jobId) throws JSONException, ValidatorServiceException {

        return validatorService.reSubmitJobForValidation(email, jobId);

    }

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

    @ResponseBody

    public List<RuleSet> getRuleSets(@PathVariable("mode") String mode) {

        return validatorService.getRuleSets(mode);

    }

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

    @ResponseBody

    public List<String> getSetsOfRepository(@RequestParam(value = "url", required = true) String url) {

        return validatorService.getSetsOfRepository(url);

    }

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

    @ResponseBody

    public boolean identifyRepo(@RequestParam(value = "url", required = true) String url) {

        return validatorService.identifyRepo(url);

    }

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

    @ResponseBody

    public RuleSet getRuleSet(@PathVariable("acronym") String acronym) {

        return validatorService.getRuleSet(acronym);

    }

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

    @ResponseBody

    @PreAuthorize("hasRole('ROLE_USER')")

    public List<StoredJob> getStoredJobsNew(@RequestParam("user") @ApiParam(value = "User email", required = true) String user,

                                            @RequestParam(value = "jobType", required = false)

                                            @ApiParam(value = "Equals to filter job type on validation history page") String jobType,

                                            @RequestParam("offset") @ApiParam(value = "Page number", required = true) String offset,

                                            @RequestParam(value = "limit", required = false,defaultValue = "10") @ApiParam(value = "Null value") String limit,

                                            @RequestParam(value = "dateFrom", required = false) @ApiParam(value = "Null value") String dateFrom,

                                            @RequestParam(value = "dateTo", required = false) @ApiParam(value = "Null value") String dateTo,

                                            @RequestParam("validationStatus") @ApiParam(value = "Equals to filter validation jobs", required = true) String validationStatus

                                            ) throws ValidatorServiceException {

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

    }

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

    @ResponseBody

    public int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws  ValidatorServiceException {

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

    }

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

    @ResponseBody

    public InterfaceInformation getInterfaceInformation(@RequestParam(value = "baseUrl") String baseUrl) throws ValidationServiceException {

        return validatorService.getInterfaceInformation(baseUrl);

    }

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

    @ResponseBody

    public List<StoredJob> getInterfaceInformation(@PathVariable(value = "repoId") String repoId, @RequestParam(name = "size", defaultValue = "20") int size ) throws ValidatorServiceException, ResourceNotFoundException, JSONException {

        return validatorService.getJobsSummary(repoId,size);

    }

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

    @ResponseBody

    public void validationCompleted(

        @RequestParam(value = "interfaceId") String interfaceId,

        @RequestParam(value = "repoId") String repoId,

        @RequestParam(value = "jobId") String jobId,

        @RequestParam(value = "issuerEmail") String issuerEmail,

        @RequestParam(value = "isUpdate") boolean isUpdate,

        @RequestParam(value = "isSuccess") boolean isSuccess,

        @RequestParam(value = "scoreUsage") int scoreUsage,

        @RequestParam(value = "scoreContent") int scoreContent) throws Exception {

        emailUtils.sendUponJobCompletion(repoId,interfaceId,scoreUsage,scoreContent,isSuccess,isUpdate,issuerEmail, jobId);

    }

}

package eu.dnetlib.repo.manager.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.domain.AggregationDetails;

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

import eu.dnetlib.repo.manager.domain.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) {

           LOGGER.error(e);

        }

        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 {

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

        ObjectMapper mapper = new ObjectMapper();

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

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

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

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

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

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

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

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

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

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

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

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

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

        /*

        * typology -> platform

        * datasource class -> typology

        * */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        List organizations = new ArrayList();

        organizations.add(organization);

        repositoryMap.put("organizations",organizations);

        //TODO check identitites

        //Map<String,String> identity = new HashMap<>();

        if (repository.getPiwikInfo() != null) {

            Map<String, Object> identity = new HashMap<>();

            HashSet<Map<String, Object>> identities = new HashSet<>();

            identity.put("issuertype", "piwik");

            identity.put("pid", "piwik:" + repository.getPiwikInfo().getSiteId());