D-Net

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

package eu.dnetlib.repo.manager.config;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;

import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;

import org.springframework.web.multipart.commons.CommonsMultipartResolver;

@Configuration

@EnableGlobalMethodSecurity(prePostEnabled = true,proxyTargetClass = true)

public class GlobalSecurityConfiguration extends GlobalMethodSecurityConfiguration {

    @Bean

    public CommonsMultipartResolver multipartResolver(){

        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();

        multipartResolver.setMaxUploadSize(268435456);

        return multipartResolver;

    }

}

package eu.dnetlib.repo.manager.config;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.log4j.Logger;

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

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration

@EnableTransactionManagement

public class DatasourceConfiguration {

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

    @Value("${repomanager.db.driverClassName}")

    private String driverClassname;

    @Value("${repomanager.db.url}")

    private String URL;

    @Value("${repomanager.db.username}")

    private String username;

    @Value("${repomanager.db.password}")

    private String password;

    @Bean

    public BasicDataSource dataSource(){

        BasicDataSource basicDataSource = new BasicDataSource();

        basicDataSource.setDriverClassName(driverClassname);

        basicDataSource.setUrl(URL);

        basicDataSource.setUsername(username);

        basicDataSource.setPassword(password);

        basicDataSource.setMaxIdle(10);

        basicDataSource.setMaxActive(100);

        basicDataSource.setMaxWait(1000);

        basicDataSource.setValidationQuery("SELECT 1;");

        basicDataSource.setTestOnBorrow(true);

        basicDataSource.setTestOnReturn(true);

        basicDataSource.setTestWhileIdle(true);

        basicDataSource.setTimeBetweenEvictionRunsMillis(1200000);

        basicDataSource.setMinEvictableIdleTimeMillis(1800000);

        basicDataSource.setMinEvictableIdleTimeMillis(5);

        basicDataSource.setPoolPreparedStatements(true);

        basicDataSource.setDefaultAutoCommit(true);

        return basicDataSource;

    }

    @Bean

    public DataSourceTransactionManager txManager(){

        DataSourceTransactionManager txManager = new DataSourceTransactionManager();

        txManager.setDataSource(dataSource());

        return txManager;

    }

}

}

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

import org.apache.log4j.Logger;

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

import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;

import org.springframework.context.annotation.*;

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

import org.springframework.http.HttpHeaders;

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

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 org.springframework.web.client.RestTemplate;

import javax.annotation.PostConstruct;

@Configuration

@EnableRedisHttpSession

@EnableAspectJAutoProxy

@EnableCircuitBreaker

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

@ComponentScan(basePackages = {

        "org.eurocris.openaire.cris.validator.service",

        "eu.dnetlib.repo.manager.*"})

public class RedisConfiguration {

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

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

    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(String.format("Redis : %s Port : %s Password : %s",host,port,password));

    }

    @Bean

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

        jedisConnectionFactory.setUsePool(true);

        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;

    }

    @Bean

    public RestTemplate restTemplate() {

        RestTemplate restTemplate = new RestTemplate();

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

        HttpHeaders httpHeaders = new HttpHeaders();

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

        return restTemplate;

    }

}

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

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

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

                <!--                <value>classpath*:dnet-override.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>-->

api.baseAddress=https://dev-openaire.d4science.org/openaire