D-Net

{

  "type_source": "SVN", 

  "goal": "package -U -T 4C source:jar", 

  "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-user-management/trunk",

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

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

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

  "name": "uoa-user-management"

}

package eu.dnetlib.openaire.user;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

/**

 * Unit test for simple App.

 */

public class AppTest 

    extends TestCase

{

    /**

     * Create the test case

     *

     * @param testName name of the test case

     */

    public AppTest( String testName )

    {

        super( testName );

    }

    /**

     * @return the suite of tests being tested

     */

    public static Test suite()

    {

        return new TestSuite( AppTest.class );

    }

    /**

     * Rigourous Test :-)

     */

    public void testApp()

    {

        assertTrue( true );

    }

}

openaire.users.db.driverClassName = org.postgresql.Driver

openaire.users.db.url = jdbc:postgresql://mpagasas.di.uoa.gr:5433/MigrationUser

openaire.users.db.username = postgres

openaire.users.db.password = 1@3$56213980

oidc.secret = U_gLOupYu2trYIOwfxGgZkkZoOHG_zGfaViOUsXcZ7qVQuF1rcJeQYKIDX1TY3z27CIoHaqq9ht2rmAiUmBRYQ

oidc.id = 24e83176-1312-4ba3-bc0b-ffeebea1603e

oidc.issuer = https://aai.openminted.eu/oidc/

oidc.home =  http://mpagasas.di.uoa.gr:8080/uoa-user-management-1.0.0-SNAPSHOT/openid_connect_login

webbapp.front = http://scoobydoo.di.uoa.gr:5000/search/find

webbapp.front.path = /

#webbapp.front.path = /search/

webbapp.front.domain = .di.uoa.gr

services.userman.ldap.address = esperos.di.uoa.gr

services.userman.ldap.username = cn=admin,dc=openaire,dc=eu

services.userman.ldap.usersDN = ou=users,dc=openaire,dc=eu

services.userman.ldap.password = serenata

services.userman.ldap.port = 389

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

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

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

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

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

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

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

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

        http://www.springframework.org/schema/util

        http://www.springframework.org/schema/util/spring-util.xsd"

       default-autowire="byName"> -->

<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:security="http://www.springframework.org/schema/security"

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

       xsi:schemaLocation="

		http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-4.2.xsd

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

		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd

		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"

       default-autowire="byType">

    <bean id="dataSourceConnector" class="eu.dnetlib.openaire.user.store.DataSourceConnector" init-method="init" autowire="byName">

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

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

        <property name="dbUrl" value="${openaire.users.db.url}" />

        <property name="driver" value="${openaire.users.db.driverClassName}" />

    </bean>

    <bean id="sqlMigrationUserDAO" class="eu.dnetlib.openaire.user.dao.SQLMigrationUserDAO" autowire="byName"/>

    <bean id="ldapConnector" class="eu.dnetlib.openaire.user.store.LDAPConnector">

        <property name="address" value="${services.userman.ldap.address}"/>

        <property name="username" value="${services.userman.ldap.username}"/>

        <property name="usersDN" value="${services.userman.ldap.usersDN}" />

        <property name="password" value="${services.userman.ldap.password}" />

        <property name="port" value="${services.userman.ldap.port}" />

    </bean>

    <bean id="mUserActionsLDAP" class="eu.dnetlib.openaire.user.ldap.MUserActionsLDAP"/>

    <security:global-method-security pre-post-annotations="enabled" proxy-target-class="true" authentication-manager-ref="authenticationManager"/>

    <security:http auto-config="false" use-expressions="true"

                   disable-url-rewriting="true" entry-point-ref="authenticationEntryPoint"

                   pattern="/**">

        <security:custom-filter before="PRE_AUTH_FILTER" ref="openIdConnectAuthenticationFilter" />

        <!--<security:logout />-->

    </security:http>

    <bean id="requestContextFilter" class="org.springframework.web.filter.RequestContextFilter"/>

    <bean id="webexpressionHandler"

          class="org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler"/>

    <bean id="authenticationEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint" >

        <constructor-arg type="java.lang.String" value="/openid_connect_login"/>

    </bean>

    <security:authentication-manager alias="authenticationManager">

        <security:authentication-provider ref="openIdConnectAuthenticationProvider" />

    </security:authentication-manager>

    <bean id="openIdConnectAuthenticationProvider" class="org.mitre.openid.connect.client.OIDCAuthenticationProvider">

        <property name="authoritiesMapper">

            <bean class="org.mitre.openid.connect.client.NamedAdminAuthoritiesMapper">

                <property name="admins" ref="namedAdmins" />

            </bean>

        </property>

    </bean>

    <util:set id="namedAdmins" value-type="org.mitre.openid.connect.client.SubjectIssuerGrantedAuthority">

        <!--

            This is an example of how to set up a user as an administrator: they'll be given ROLE_ADMIN in addition to ROLE_USER.

            Note that having an administrator role on the IdP doesn't grant administrator access on this client.

            These are values from the demo "openid-connect-server-webapp" project of MITREid Connect.

        -->

        <bean class="org.mitre.openid.connect.client.SubjectIssuerGrantedAuthority">

            <constructor-arg name="subject" value="subject_value" />

            <constructor-arg name="issuer" value="${oidc.issuer}" />

        </bean>

    </util:set>

    <bean class="eu.dnetlib.openaire.user.security.FrontEndLinkURIAuthenticationSuccessHandler" id="frontEndRedirect">

        <property name="frontEndURI" value="${webbapp.front}"/>

        <property name="frontPath" value="${webbapp.front.path}"/>

        <property name="frontDomain" value="${webbapp.front.domain}"/>

    </bean>

    <bean id="securityContextLogoutHandler" class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler"/>

    <!--<bean id="logoutFilter" class="org.springframework.security.web.authentication.logout.LogoutFilter">-->

        <!--<property name="filterProcessesUrl" value="/logout"/>-->

        <!--<constructor-arg index="0" value="/"/>-->

        <!--<constructor-arg index="1">-->

            <!--<list>-->

                <!--<ref bean="securityContextLogoutHandler"/>-->

                <!--&lt;!&ndash;ref bean="myLogoutHandler"/&ndash;&gt;-->

            <!--</list>-->

        <!--</constructor-arg>-->

    <!--</bean>-->

    <bean class="eu.dnetlib.openaire.user.security.FrontEndLinkURILogoutSuccessHandler" id="frontEndRedirectLogout"/>

    <bean id="logoutFilter" class="org.springframework.security.web.authentication.logout.LogoutFilter">

        <property name="filterProcessesUrl" value="/logout"/>

        <constructor-arg index="0" value="/"/>

        <constructor-arg index="1">

            <list>

                <ref bean="securityContextLogoutHandler"/>

                <!--ref bean="myLogoutHandler"/-->

            </list>

        </constructor-arg>

    </bean>

    <!--

      -

      - The authentication filter

      -

      -->

    <bean id="openIdConnectAuthenticationFilter" class="org.mitre.openid.connect.client.OIDCAuthenticationFilter">

        <property name="authenticationManager" ref="authenticationManager" />

        <property name="issuerService" ref="staticIssuerService" />

        <property name="serverConfigurationService" ref="staticServerConfigurationService" />

        <property name="clientConfigurationService" ref="staticClientConfigurationService" />

        <property name="authRequestOptionsService" ref="staticAuthRequestOptionsService" />

        <property name="authRequestUrlBuilder" ref="plainAuthRequestUrlBuilder" />

        <property name="authenticationSuccessHandler" ref="frontEndRedirect"/>

    </bean>

    <!--

        Static issuer service, returns the same issuer for every request.

    -->

    <bean class="org.mitre.openid.connect.client.service.impl.StaticSingleIssuerService" id="staticIssuerService">

        <property name="issuer" value="${oidc.issuer}" />

    </bean>

    <!--

        Dynamic server configuration, fetches the server's information using OIDC Discovery.

    -->

    <bean class="org.mitre.openid.connect.client.service.impl.StaticServerConfigurationService" id="staticServerConfigurationService">

        <property name="servers">

            <map>

                <entry key="${oidc.issuer}">

                    <bean class="org.mitre.openid.connect.config.ServerConfiguration">

                        <property name="issuer" value="${oidc.issuer}" />

                        <property name="authorizationEndpointUri"	value="${oidc.issuer}authorize" />

                        <property name="tokenEndpointUri"	value="${oidc.issuer}token" />

                        <property name="userInfoUri" value="${oidc.issuer}userinfo" />

                        <property name="jwksUri" value="${oidc.issuer}jwk" />

                        <property name="revocationEndpointUri" value="${oidc.issuer}revoke" />

                    </bean>

                </entry>

            </map>

        </property>

    </bean>

    <!--

       Static Client Configuration. Configures a client statically by storing configuration on a per-issuer basis.

    <bean class="org.mitre.openid.connect.client.service.impl.StaticClientConfigurationService" id="staticClientConfigurationService">

        <property name="clients">

            <map>

                <entry key="${oidc.issuer}">

                    <bean class="org.mitre.oauth2.model.RegisteredClient">

                        <property name="clientId" value="${oidc.id}" />

                        <property name="clientSecret" value="${oidc.secret}" />

                        <property name="scope">

                            <set value-type="java.lang.String">

                                <value>openid</value>

                            </set>

                        </property>       xmlns:oauth="http://www.springframework.org/schema/security/oauth2"

                        <property name="tokenEndpointAuthMethod" value="SECRET_BASIC" />

                        <property name="redirectUris">

                            <set>

                                <value>${oidc.home}</value>

                            </set>

                        </property>

                    </bean>

                </entry>

            </map>

        </property>

    </bean>

-->

    <bean class="org.mitre.openid.connect.client.service.impl.StaticClientConfigurationService" id="staticClientConfigurationService">

        <property name="clients">

            <map>

                <entry key="${oidc.issuer}">

                    <bean class="org.mitre.oauth2.model.RegisteredClient">

                        <property name="clientId" value="${oidc.id}" />

                        <property name="clientSecret" value="${oidc.secret}" />

                        <property name="scope">

                            <set value-type="java.lang.String">

                                <value>openid</value>

                            </set>

                        </property>

                        <property name="tokenEndpointAuthMethod" value="SECRET_BASIC" />

                        <property name="redirectUris">

                            <set>

                                <value>${oidc.home}</value>

                            </set>

                        </property>

                    </bean>

                </entry>

            </map>

        </property>

    </bean>

    <!--

      -

      -	Auth request options service: returns the optional components of the request

      -

      -->

    <bean class="org.mitre.openid.connect.client.service.impl.StaticAuthRequestOptionsService" id="staticAuthRequestOptionsService">

        <property name="options">

            <map>

                <!-- Entries in this map are sent as key-value parameters to the auth request -->

                <!--

                <entry key="display" value="page" />

                <entry key="max_age" value="30" />

                <entry key="prompt" value="none" />

                -->

            </map>

        </property>

    </bean>

    <!--

        Plain authorization request builder, puts all options as query parameters on the GET request

    -->

    <bean class="org.mitre.openid.connect.client.service.impl.PlainAuthRequestUrlBuilder" id="plainAuthRequestUrlBuilder" />

    <context:component-scan base-package="eu.dnetlib.openaire.user.api.services" />

</beans>

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

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

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

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

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

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

	   http://www.springframework.org/schema/context

		   http://www.springframework.org/schema/context/spring-context-4.2.xsd">

    <import resource="classpath*:/eu/dnetlib/openaire/user/springContext-userManagementService.xml" />

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

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

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

        <property name="properties">

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

                <property name="propertyFetcher">

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

                </property>

            </bean>

        </property>

        <property name="locations">

            <list>

                <value>classpath*:/eu/**/applicationContext*.properties</value>

                <value>classpath*:/eu/dnetlib/applicationContext-defaultProperties.properties</value>

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

                <value>classpath*:/uoa-override.properties</value>

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

            </list>

        </property>

    </bean>

    <context:annotation-config />

</beans>

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

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

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

	    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

</beans>

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

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

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

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

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

             xsi:schemaLocation="

    	http://www.springframework.org/schema/beans

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

        http://www.springframework.org/schema/security

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

    <!-- Stateless RESTful services use BASIC authentication -->

    <!--<security:http create-session="stateless" pattern="/rest/**">

         <security:intercept-url pattern="/**" access="ROLE_REST"/>

        <security:http-basic/>

    </security:http>

     <security:authentication-manager>

         <security:authentication-provider>

             <security:user-service>

                 <security:user name="rest" password="rest" authorities="ROLE_REST"/>

             </security:user-service>

         </security:authentication-provider>

     </security:authentication-manager>

    -->

    <!--

    <authentication-manager alias="authenticationManager">

        <authentication-provider ref="jwtAuthenticationProvider" />  (8)

    </authentication-manager>

    -->

</beans:beans>

log4j.rootLogger = DEBUG, R

log4j.logger.eu.dnetlib = DEBUG

log4j.logger.org.mitre.openid = DEBUG

log4j.logger.org.springframework = DEBUG, S

#log4j.additivity.org.springframework = false

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=/var/log/dnet/user-management/user-management.log

log4j.appender.R.MaxFileSize=10MB

log4j.appender.R.MaxBackupIndex=10

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern= %d %p %t [%c] - %m%n

log4j.appender.S=org.apache.log4j.RollingFileAppender

log4j.appender.S.File=/var/log/dnet/user-management/user-management-spring.log

log4j.appender.S.MaxFileSize=10MB

log4j.appender.S.MaxBackupIndex=10

log4j.appender.S.layout=org.apache.log4j.PatternLayout

log4j.appender.S.layout.ConversionPattern= %d %p %t [%c] - %m%n

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

<web-app>

    <display-name>uoa-user-management</display-name>

    <context-param>

        <param-name>webAppRootKey</param-name>

        <param-value>uoa-user-management</param-value>

    </context-param>

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>

            /WEB-INF/applicationContext.xml

            /WEB-INF/security-context.xml

        </param-value>

    </context-param>

    <context-param>

        <param-name>log4jConfigLocation</param-name>

        <param-value>/WEB-INF/log4j.properties</param-value>

    </context-param>

    <listener>

        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>

    </listener>

    <listener>

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>

    <servlet>

        <servlet-name>User API</servlet-name>

        <servlet-class>com.sun.jersey.spi.spring.container.servlet.SpringServlet</servlet-class>

        <init-param>

            <param-name>com.sun.jersey.config.property.packages</param-name>

            <param-value>eu.dnetlib.openaire.user.api.services</param-value>

        </init-param>

    </servlet>

    <servlet-mapping>

        <servlet-name>User API</servlet-name>

        <url-pattern>/api/*</url-pattern>

    </servlet-mapping>

    <filter>

        <filter-name>CorsFilter</filter-name>

        <filter-class>org.apache.catalina.filters.CorsFilter</filter-class>

        <init-param>

            <param-name>cors.allowed.origins</param-name>

            <param-value>*</param-value>

        </init-param>

        <init-param>

            <param-name>cors.allowed.methods</param-name>

            <param-value>GET, POST</param-value>

        </init-param>

        <init-param>

            <param-name>cors.exposed.headers</param-name>

            <param-value>Access-Control-Allow-Origin,Access-Control-Allow-Credentials,Access-Control-Allow-Methods</param-value>

        </init-param>

        <init-param>

            <param-name>cors.support.credentials</param-name>

            <param-value>true</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>CorsFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

<!--

    <filter>

        <filter-name>requestContextFilter</filter-name>

        <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>requestContextFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

-->

    <filter>

        <filter-name>springSecurityFilterChain</filter-name>

        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

    </filter>

    <filter-mapping>

        <filter-name>springSecurityFilterChain</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

</web-app>

package eu.dnetlib.openaire.user;

import eu.dnetlib.openaire.user.user.UserProfile;

/**

 * Created by sofia on 31/10/2016.

 */

public interface IUserActions {

    public String addUser(String email, String password) throws Exception;

    public boolean activateUser(String activationId) throws Exception;

    public boolean isUserActivated(String email) throws Exception;

    public boolean userExists(String email) throws Exception;

    public boolean usernameExists(String username) throws Exception;

    public boolean correctCreds(String email, String password) throws Exception;

    public String prepareResetPassword(String email) throws Exception;

    public void resetPassword(String uuid, String password) throws Exception;

    public boolean isAdmin(String email) throws Exception;

    public void editUser(String email, String fname, String lname, String inst)

            throws Exception;

    public String addUser(String username, String email, String password,

                          String firstName, String lastName) throws Exception;

    public String getEmailFromUsername(String username) throws Exception;

    public UserProfile getUser(String userIdentifier) throws Exception;

}

package eu.dnetlib.openaire.user;

import java.io.Serializable;

/**

 * Created by sofia on 1/11/2016.

 */

public class MigrationUser implements Serializable {

    private int id;

    private String username; // LDAP's cn, it is unique key

    private String fullname; // LDAP's display name

    private String email;

    private int roleId;

    public MigrationUser() {

    }

    public MigrationUser(String username) {

        this.username = username;

    }

    public MigrationUser(int id, String username, String fullname, String email, int roleId) {

        this.id = id;

        this.username = username;

        this.fullname = fullname;

        this.email = email;

        this.roleId = roleId;

    }

    public int getId(){

        return id;

    }

    public void setId(int id){

        this.id = id;

    }

    public String getUsername(){

        return username;

    }

    public void setUsername(String username){

        this.username = username;

    }

    public String getFullname(){

        return fullname;

    }

    public void setFullname(String fullname){

        this.fullname = fullname;

    }

    public String getEmail(){

        return email;

    }

    public void setEmail(String email){

        this.email = email;

    }

    public int getRoleId(){

        return roleId;

    }

    public void setRoleId(int roleId){

        this.roleId = roleId;

    }

}

package eu.dnetlib.openaire.user.api.services;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.google.gson.Gson;

import com.google.gson.JsonObject;

import com.google.gson.JsonParser;

import com.unboundid.ldap.sdk.LDAPException;

import eu.dnetlib.openaire.user.LDAPUser;

import eu.dnetlib.openaire.user.MigrationUser;

import eu.dnetlib.openaire.user.Role;

import eu.dnetlib.openaire.user.dao.RoleDAO;

import eu.dnetlib.openaire.user.dao.SQLMigrationUserDAO;

import eu.dnetlib.openaire.user.ldap.MUserActionsLDAP;

import eu.dnetlib.openaire.user.security.JWTGenerator;

import eu.dnetlib.openaire.user.store.DataSourceConnector;

import org.apache.log4j.Logger;

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

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

import org.springframework.http.*;

import org.springframework.http.HttpMethod;

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

import javax.ws.rs.*;

import javax.ws.rs.core.MediaType;

import javax.ws.rs.core.Response;

import java.io.OutputStream;

import java.sql.SQLException;

/**

 * Created by sofia on 24/11/2016.

 */

@Component

@Path("/users")

public class Test3Service {

    private static final Logger logger = Logger.getLogger(Test3Service.class);

    @Autowired

    private SQLMigrationUserDAO sqlMigrationUserDAO;

    @Autowired

    private MUserActionsLDAP mUserActionsLDAP;

    @Autowired

    private DataSourceConnector dataSourceConnector;

    @GET

    @Path("/{userId}")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getUserById(@PathParam("userId") int userId) {

        try {

            MigrationUser mUser = sqlMigrationUserDAO.fetchById(userId);

            // Invalide user ID

            if (mUser == null) {

                String errorMessageJson = compose404Message("Cannot find user with id " + userId + ".");

                return Response

                        .status(Response.Status.NOT_FOUND)

                        .entity(errorMessageJson)

                        .type(MediaType.APPLICATION_JSON)

                        .build();

            }

            return Response.status(200).entity(composeDataResponse(mUser)).build();

        }

        catch (SQLException e) {

            return Response

                    .status(Response.Status.INTERNAL_SERVER_ERROR)

                    .entity(compose500Message("Fail to fetch users.", e))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

    }

     /* How to check @browser ../authenticate/?username=MY_USERNAME&password=MY_PASSWORD

     * http://localhost:8080/uoa-user-management-1.0.0-SNAPSHOT/api/users/authenticate?username=sba&password=12345678

    @GET

    @Path("/authenticate")

    @Produces(MediaType.APPLICATION_JSON)

    public Response authenticateUserGET(@QueryParam("username") String username, @QueryParam("password") String password)

    {

        return commonAuthenticateFunction(username, password);

    }*/

    @POST

    @Path("/authenticates")

    @Produces(MediaType.APPLICATION_JSON)

    @Consumes(MediaType.APPLICATION_JSON)

    public Response authenticateUserPOST(String input) {

        JsonObject jsonObject = new JsonParser().parse(input).getAsJsonObject();

        String username = jsonObject.get("username").getAsString();

        String password = jsonObject.get("password").getAsString();

        return commonAuthenticateFunction(username, password);

    }

    private Response commonAuthenticateFunction(String username, String password)

    {

        try {

            boolean usernameExists = mUserActionsLDAP.usernameExists(username);

            // if user was not found

            if (!usernameExists) {

                String errorMessageJson = compose401Message("Wrong credentials.");

                return Response

                        .status(Response.Status.UNAUTHORIZED)

                        .entity(errorMessageJson)

                        .type(MediaType.APPLICATION_JSON)

                        .build();

            }

            boolean authenticated = mUserActionsLDAP.authenticate(username, password);

            // if user was not authenticated

            if (!authenticated) {

                return Response

                        .status(Response.Status.UNAUTHORIZED)

                        .entity(compose401Message("User " + username + " could not be authenticated."))

                        .type(MediaType.APPLICATION_JSON)

                        .build();

            }

            MigrationUser mUser = sqlMigrationUserDAO.fetchByUsername(username);

            // if user was not found in my db

            LDAPUser ldapUser = null;

            if (mUser == null) {

                mUser = new MigrationUser(username);

                ldapUser = mUserActionsLDAP.getUser(username);

                mUser.setFullname(ldapUser.getDisplayName());

                mUser.setEmail(ldapUser.getEmail());

                mUser.setRoleId(2);

                sqlMigrationUserDAO.insert(mUser);

            }

            return Response.status(200).entity(composeDataResponse(mUser)).type(MediaType.APPLICATION_JSON).build();

        } catch (LDAPException exc) {

            logger.error("Fail to connect to LDAP. ", exc);

            return Response

                    .status(Response.Status.INTERNAL_SERVER_ERROR)

                    .entity(compose500Message("LDAP error.", exc))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        } catch (SQLException exc) {

            logger.error("Fail to fetch users. ", exc);

            return Response

                    .status(Response.Status.INTERNAL_SERVER_ERROR)

                    .entity(compose500Message("Fail to fetch users.", exc))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

    }

    @GET

    @Path("/changeRole")

    @Produces(MediaType.APPLICATION_JSON)

    public Response changeRole(@QueryParam("roleId") int roleId, @QueryParam("userId") int userId)

    {

        RoleDAO roleDAO = new RoleDAO();

        try

        {

            Role role = roleDAO.fetchById(roleId);

            if (role == null)

            {

                //fetch all roleids TODO

                String errorMessageJson = compose404Message("Cannot find role with id" + roleId + ".");

                return Response

                        .status(Response.Status.NOT_FOUND)

                        .entity(errorMessageJson)

                        .type(MediaType.APPLICATION_JSON)

                        .build();

            }

            MigrationUser mUser = sqlMigrationUserDAO.fetchById(userId);

            if (mUser == null)

            {

                String errorMessageJson = compose404Message("Cannot find user with id " + userId + ".");

                return Response

                        .status(Response.Status.NOT_FOUND)

                        .entity(errorMessageJson)

                        .type(MediaType.APPLICATION_JSON)

                        .build();

            }

            mUser.setRoleId(roleId);

            sqlMigrationUserDAO.update(mUser);

            return Response.status(200).entity(composeDataResponse(mUser)).build();

        }

        catch (SQLException exc)

        {

            return Response

                    .status(Response.Status.INTERNAL_SERVER_ERROR)

                    .entity(compose500Message("Fail to fetch users.", exc))

                    .type(MediaType.APPLICATION_JSON)

                    .build();

        }

    }

    @GET

    @Path("/getUserInfo")

    @Produces(MediaType.APPLICATION_JSON)

    public Response getUserInfo(@QueryParam("accessToken") String accessToken) throws JsonProcessingException {

        //return Response.status(404).entity(compose404Message("This is a test message.")).type(MediaType.APPLICATION_JSON).build();

        // call aai with accessToken

        RestTemplate restTemplate = new RestTemplate();

        HttpHeaders headers = new HttpHeaders();

        headers.add("Authorization","Bearer " + accessToken);

        HttpEntity request = new HttpEntity(null, headers);

        String fooResourceUrl = "https://aai.openminted.eu/oidc/userinfo";

        logger.info(restTemplate.exchange(fooResourceUrl, HttpMethod.GET, request, Object.class));

        ResponseEntity response1 = restTemplate.exchange(fooResourceUrl, HttpMethod.GET, request, Object.class);

        logger.info(response1.getBody().toString());

        ObjectMapper mapper = new ObjectMapper();

        return Response.status(response1.getStatusCode().value()).entity(mapper.writeValueAsString(response1.getBody())).type(MediaType.APPLICATION_JSON).build();

    }

    /* JSON Utility Methods */

    private String compose401Message(String message) {

        return  "{ \"status\" : \"error\", \"code\" : \"401\", \"message\" : \"  " + message +" \" }";

    }

    private String compose404Message(String message) {

        return  "{ \"status\" : \"error\", \"code\" : \"404\", \"message\" : \"  " + message +" \" }";

    }

    private String compose500Message(String message, Exception exception) {

        return  "{ \"status\" : \"fail\", \"code\" : \"500\", \"message\" : \"  " + message + "\", " +

                "\"description\" : \""+  exception.getMessage() +"\" }";

    }

    private String composeDataResponse(UserInfo user) {

        return "{ \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : \"" + JWTGenerator.generateToken(user, "my-very-secret") + "\" }";

    }

    private String composeDataResponse(MigrationUser user) {

        //return "{ \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : " + new Gson().toJson(user) + " }";

        return "{ \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : \"" + JWTGenerator.generateToken(user, "my-very-secret") + "\" }";

    }

    private String composeDataResponse(LDAPUser user) {

        return " { \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : " + new Gson().toJson(user) + " }";

    }

//        private String composeDataResponse(String username) {

//            return " { \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : " + new Gson().toJson(username) + " }";

//        }

    private String composeDataResponse(String fullname) {

        return " { \"status\" : \"success\", \"code\": \"200\", " + "\"data\" : " + new Gson().toJson(fullname) + " }";

    }

}

package eu.dnetlib.openaire.user.migration;

import com.sun.org.apache.xpath.internal.SourceTree;

import com.unboundid.ldap.sdk.*;

import eu.dnetlib.openaire.user.ldap.Joomla15PasswordHash;

import eu.dnetlib.openaire.user.ldap.MUserActionsLDAP;

import eu.dnetlib.openaire.user.ldap.UserActionsLDAP;

import java.sql.SQLException;

import java.util.UUID;

/**

 * Created by sofia on 25/4/2017.

 */

public class Tester {

    public static void main(String[] args) throws LDAPException, SQLException {

        // ldapsearch -x -LLL -h beta.openaire.eu -b cn=admin,dc=openaire,dc=eu

        // ldap_sasl_bind(SIMPLE): Can't contact LDAP server (-1)

//        String ldapAddress = "beta.openaire.eu";

//        String ldapUsername = "cn=admin,dc=openaire,dc=eu";

//        String ldapPassword = "";

          String ldapUsersDN = "ou=users,dc=openaire,dc=eu";

//        int ldapPort = 389;

//

//        LDAPConnection connection = new LDAPConnection(ldapAddress, ldapPort, ldapUsername, ldapPassword);

        LDAPConnection connection = new LDAPConnection("beta.openaire.eu", 389, "cn=admin,dc=openaire,dc=eu", "");

        System.out.println("Hi");

        String email = "sbaltzi@di.uoa.gr";

        String password = "";

        try {

            System.out.println("checking if user " + email + " entered a correct password when logging in");

            Filter filter = Filter.createEqualityFilter("mail", email);

            SearchRequest searchRequest = new SearchRequest(ldapUsersDN, SearchScope.SUB, filter, "userPassword");

            SearchResult searchResult = connection.search(searchRequest);

            for (SearchResultEntry entry : searchResult.getSearchEntries()) {

                if (Joomla15PasswordHash.check(password, entry.getAttributeValue("userPassword")))

                    System.out.println("true");

            }

            System.out.println("false");

        }

        finally {

            if (connection != null)

                connection.close();

        }

    }

}

package eu.dnetlib.openaire.user.migration;

import com.unboundid.ldap.sdk.*;

import eu.dnetlib.openaire.user.ldap.Joomla15PasswordHash;

import eu.dnetlib.openaire.user.ldap.MUserActionsLDAP;

import eu.dnetlib.openaire.user.ldap.UserActionsLDAP;

import eu.dnetlib.openaire.user.store.LDAPConnector;

import java.sql.SQLException;

import java.util.UUID;

/**

 * Created by sofia on 31/10/2016.

 */

public class Migration {

    public static void main(String[] args) throws LDAPException, SQLException {

        //MUserActionsLDAP mUserActionsLDAP = new MUserActionsLDAP();

//        UserActionsLDAP UserActionsLDAP = new UserActionsLDAP();

//        try {

//            UserActionsLDAP.addUser("Argiro", "argiro@gmail.com", "12345678", "Argiro", "Kokogianaki");

//        } catch (Exception e) {

//            e.printStackTrace();

//        }

        //boolean authenticated = mUserActionsLDAP.authenticateUser("sba@di.uoa.gr", "12345678");

        //System.out.println(authenticated);

        //System.out.println(mUserActionsLDAP.getRole("sba@di.uoa.gr", "12345678"));

        Attribute cn = new Attribute("cn", "Argiro");

        Attribute displayName = new Attribute("displayName", "Argiro" + " " + "Kokogianaki");

        Attribute mail = new Attribute("mail", "argiro@gmail.com");

        Attribute givenName = new Attribute("givenName", "Argiro");

        Attribute joomlaBlockUser = new Attribute("JoomlaBlockUser", "1");

        Attribute joomlaGroup = new Attribute("JoomlaGroup", "Registered");

        Attribute objectClass = new Attribute("objectClass", "top", "inetOrgPerson", "JoomlaUser");

        Attribute userPassword = new Attribute("userPassword", Joomla15PasswordHash.create("12345678"));

        Attribute sn = new Attribute("sn", "Kokogianaki");

        Attribute uid = new Attribute("uid", "Argiro");

        // Attribute joomlaUserParams = new Attribute("JoomlaUserParams", "");

        String activationId = UUID.randomUUID().toString();

        Attribute x500UniqueIdentifier = new Attribute("employeeNumber", activationId);

        LDAPConnection connection = null;

        try {

            DN dn = new DN("uid=" + "Argiro" + "," + "ou=users,dc=openaire,dc=eu");

            System.out.println("cn: " + cn + " displayName: " + displayName + " mail: " + mail + " givenName: " + givenName + " joomlaBlockUser: " + joomlaBlockUser + " joomlaGroup: " + joomlaGroup + " objectClass: " + objectClass + " userPassword: " + userPassword + " sn: " + sn + " uid: " + uid + " x500UniqueIdentifier: " + x500UniqueIdentifier);

            Entry entry = new Entry(dn.toNormalizedString(), cn, displayName, mail, givenName, joomlaBlockUser, joomlaGroup, objectClass, userPassword, sn, uid/*

																																								 * ,

																																								 * joomlaUserParams

																																								 */, x500UniqueIdentifier);

            connection = new LDAPConnection("esperos.di.uoa.gr", 389, "cn=admin,dc=openaire,dc=eu", "serenata");

            connection.add(entry);

        } catch (Exception e) {

            throw e;

        } finally {

            if (connection != null)

                connection.close();

        }

    }

}

package eu.dnetlib.openaire.user.store;

import java.sql.PreparedStatement;

import java.sql.SQLException;

/**

 * Created by sofia on 28/6/2016.

 */

public class Statement

{

    public interface Initializer {

        void prepare(PreparedStatement stmt) throws SQLException;

    }

    private static final Initializer EMPTY = new Initializer() {

        @Override

        public void prepare(PreparedStatement stmt) throws SQLException {}

    };

    public static Initializer emptyInitializer() {

        return EMPTY;

    }

}

package eu.dnetlib.openaire.user.store;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.log4j.Logger;

import javax.sql.DataSource;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

/**

 * Created by sofia on 31/10/2016.

 */

public class DataSourceConnector {

    private String username;

    private String password;

    private String dbUrl;

    private String driver;

    private static boolean driverLoad = false;

    private DataSource datasource;

    private static final Logger logger = Logger.getLogger(DataSourceConnector.class);

    public void init() {

        logger.info("Initializing data source");

        try {

            Class.forName(driver);

            driverLoad = true;

            BasicDataSource bds = new BasicDataSource();

            bds.setDriverClassName(driver);

            bds.setUrl(dbUrl);

            bds.setUsername(username);

            bds.setPassword(password);

            bds.setMaxIdle(10);

            bds.setMaxActive(100);

            bds.setMaxWait(10000);

            bds.setValidationQuery("select 1");

            bds.setTestOnBorrow(true);

            bds.setTestWhileIdle(true);

            bds.setTimeBetweenEvictionRunsMillis(1200000);

            bds.setMinEvictableIdleTimeMillis(1800000);

            bds.setNumTestsPerEvictionRun(5);

            bds.setDefaultAutoCommit(true);

            this.datasource = bds;

            // Test Connection

            getConnection().close();

            logger.info("Datasource " + datasource);

            logger.info(datasource.getConnection());

        } catch (ClassNotFoundException | SQLException exc) {

            logger.error("Unable to connenct to the DB. ", exc);

            throw new RuntimeException(exc);

        }

    }

    public Connection getConnection() throws SQLException {

        logger.debug("dbUrl " + dbUrl);

        return DriverManager.getConnection(dbUrl, username, password);

        //return DriverManager.getConnection("jdbc:postgresql://localhost:5433/MigrationUser?user=postgres&password=mypassword");

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public String getDbUrl() {

        return dbUrl;

    }

    public void setDbUrl(String dbUrl) {

        this.dbUrl = dbUrl;

    }

    public String getDriver() {

        return driver;

    }

    public void setDriver(String driver) {

        this.driver = driver;

    }

    public DataSource getDatasource() {

        return datasource;

    }

}

package eu.dnetlib.openaire.user.store;

/**

 * Created by sofia on 29/6/2016.

 */

public class Connector

{

}

package eu.dnetlib.openaire.user.store;

import com.unboundid.ldap.sdk.LDAPConnection;

import com.unboundid.ldap.sdk.LDAPException;

import org.apache.log4j.Logger;

/**

 * Created by sofia on 3/10/2016.

 */

public class LDAPConnector

{

    private String address;

    private String username;

    private String usersDN;

    private String password;

    private int port;

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

    public LDAPConnection getConnection() throws LDAPException {

        logger.debug("Getting ldap connection");

        return new LDAPConnection(address, port, username, password);

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getUsersDN() {

        return usersDN;

    }

    public void setUsersDN(String usersDN) {

        this.usersDN = usersDN;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public int getPort() {

        return port;

    }

    public void setPort(int port) {

        this.port = port;

    }

}

package eu.dnetlib.openaire.user.handler;

import eu.dnetlib.openaire.user.User;

import java.util.List;

/**

 * Created by sofia on 4/8/2016.

 */

public interface  UserHandler {

    public List<User> fetchAllUsers(int limit, int offset, String keyword, String orderby, boolean descending, List<String> listTypes);

    public List<User> fetchAllUsers(int limit, int offset);

    public int countAllUsers(String s, List<String> strings);

    public User fetchUserById(String userId);

    public List<User> fetchUsersByResult(String userId, int limit, int offset, String keyword, String orderby, boolean descending, List<String> listTypes);

    public int countUsersByResult(String userId, String keyword, List<String> listTypes);

}

package eu.dnetlib.openaire.user.queries;

/**

 * Created by sofia on 1/11/2016.

 */

public interface SQLMigrationUserQueries {

    // Queries (as prepared statements to avoid SQL-injection)

    String FETCH_ALL         = "SELECT * FROM users";

    String FETCH_BY_ID       = "SELECT * FROM users WHERE id = ?";

    String FETCH_BY_USERNAME = "SELECT * FROM users WHERE username = ?";

    String FETCH_BY_FULLNAME = "SELECT * FROM users WHERE fullname = ?";

    String FETCH_BY_EMAIL    = "SELECT * FROM users WHERE email = ?";

    String FETCH_BY_ROLE_ID  = "SELECT * FROM users WHERE role_id = ?";

    String COUNT_ALL = "SELECT COUNT(*) FROM users";

    String INSERT = "INSERT INTO users (" +

            "username, " +

            "fullname, " +

            "email, " +

            "role_id" +

            ") VALUES (?,?,?,?)";

    String UPDATE = "UPDATE users SET " +

            "username = ?, " +

            "fullname = ?, " +

            "email = ?, " +

            "role_id = ? " +

            "WHERE id = ?";

    String DELETE = "DELETE FROM users WHERE id = ?";

}

package eu.dnetlib.openaire.user.queries;

/**

 * Created by sofia on 8/11/2016.

 */

public interface RoleQueries {

    // Queries (as prepared statements to avoid SQL-injection)

    String FETCH_ALL     = "SELECT * FROM roles";

    String FETCH_BY_ID   = "SELECT * FROM roles WHERE id = ?";

    String FETCH_BY_ROLE = "SELECT * FROM roles WHERE role = ?";

    String COUNT_ALL = "SELECT COUNT(*) FROM role";

    String INSERT = "INSERT INTO roles (" +

            "role" +

            ") VALUES (?)";

    String UPDATE = "UPDATE roles SET " +

            "role = ? " +

            "WHERE id = ?";

    String DELETE = "DELETE FROM roles WHERE id = ?";

}

package eu.dnetlib.openaire.user;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.HashMap;

/**

 * Created by sofia on 15/6/2016.

 */

public class User implements Serializable{

    private String id;

    private String username;

    private String password;

    private String email;

    private String name;

    private String surname;

    private Map<String, List<String>> roles;

    //private int orcid;

    //private String affiliation;

    //private String profil_provenance;

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

    public User(){

    }

    public User(String username) {

        this.username = username;

    }

    public User(String id, String username, String password, String email, String name, String surname){

        this.id = id;

        this.username = username;

        this.password = password;

        this.email = email;

        this.name = name;

        this.surname = surname;

    }

    public String getId(){

        return id;

    }

    public void setId(String id){

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public String getEmail() {

        return email;

    }

    public void setEmail(String email) {

        this.email = email;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSurname() {

        return surname;

    }

    public void setSurname(String surname) {

        this.surname = surname;

    }

    public void setRoles(Map<String, List<String>> map)

    {

        this.roles = map;

    }

    public Map<String, List<String>> getValue()

    {