Changeset 4995


Ignore:
Timestamp:
04/16/14 15:35:03 (10 years ago)
Author:
olhsha@mpi.nl
Message:

adding spring security tables, hashing and the method for posting record in the spring security tables

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/Helpers.java

    r4969 r4995  
    1818package eu.dasish.annotation.backend;
    1919
     20import eu.dasish.annotation.schema.Principal;
    2021import java.io.ByteArrayInputStream;
    2122import java.io.IOException;
    2223import java.io.InputStream;
    2324import java.util.Map;
    24 import java.util.Set;
    2525import javax.xml.parsers.DocumentBuilder;
    2626import javax.xml.parsers.DocumentBuilderFactory;
    2727import javax.xml.parsers.ParserConfigurationException;
    28 import org.slf4j.Logger;
     28import org.springframework.security.authentication.encoding.ShaPasswordEncoder;
    2929import org.w3c.dom.Document;
    3030import org.w3c.dom.Element;
    … …  
    7474        return welcome;
    7575    }
     76   
     77    public static Principal createPrincipalElement(String name, String e_mail) {
     78        Principal result = new Principal();
     79        result.setDisplayName(name);
     80        result.setEMail(e_mail);
     81        return result;
     82    }
     83   
     84    public static String hashPswd(String pswd, int strength, String salt) {
     85    ShaPasswordEncoder encoder = new ShaPasswordEncoder(strength);
     86    return encoder.encodePassword(pswd, salt);
     87    }
    7688}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/PrincipalExists.java

    r4834 r4995  
    2424public class PrincipalExists extends Exception{
    2525   
    26     public PrincipalExists(String email){
    27         super("The principal with the e-mail "+email+" already exists in the database and cannot be added now. Note, e-mail are case insensitive in the database. ");
     26    public PrincipalExists(String remoteID){
     27        super("The principal with the remoteID "+remoteID+" already exists in the database and cannot be added. ");
    2828    }
    2929   

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/DBIntegrityService.java

    r4985 r4995  
    317317    Number addPrincipal(Principal principal, String remoteID) throws NotInDataBaseException, PrincipalExists;
    318318
     319    public int addSpringUser(String username, String password, int strength, String salt);
     320   
    319321       /// notebooks ////
    320322    Number createNotebook(Notebook notebook, Number ownerID) throws NotInDataBaseException;
    … …  
    322324    boolean createAnnotationInNotebook(Number notebookID, Annotation annotation, Number ownerID) throws NotInDataBaseException;
    323325
    324     public Principal createPrincipalRecord(String remoteID);
    325    
     326   
    326327    /**
    327328     * DELETERS

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/PrincipalDao.java

    r4909 r4995  
    4242     
    4343     // where is it used??
    44      public boolean principalExists(Principal principal);
     44     public boolean principalExists(String remoteID);
    4545     
    4646     public String getTypeOfPrincipalAccount(Number internalID);
    … …  
    5959     public Number addPrincipal(Principal principal, String remoteID) throws NotInDataBaseException;
    6060     
     61     public int addSpringUser(String username, String password, int strength, String salt);
     62     
     63     public int addSpringAuthorities(String username);
     64     
    6165     public int deletePrincipal(Number intenralID) throws PrincipalCannotBeDeleted;
    6266     
    63      public Principal createShibbolizedPrincipal(String remoteID);
     67     
    6468}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceImlp.java

    r4985 r4995  
    680680    @Override
    681681    public Number addPrincipal(Principal principal, String remoteID) throws NotInDataBaseException, PrincipalExists {
    682         if (principalDao.principalExists(principal)) {
    683             throw new PrincipalExists(principal.getEMail());
     682        if (principalDao.principalExists(remoteID)) {
     683            throw new PrincipalExists(remoteID);
    684684        } else {
    685685            return principalDao.addPrincipal(principal, remoteID);
    … …  
    705705        Number newAnnotationID = this.addPrincipalsAnnotation(ownerID, annotation);
    706706        return notebookDao.addAnnotationToNotebook(notebookID, newAnnotationID);
     707    }
     708   
     709    @Override
     710    public int addSpringUser(String username, String password, int strength, String salt){
     711        int users = principalDao.addSpringUser(username, password, strength, salt);
     712        int authorities = principalDao.addSpringAuthorities(username);       
     713        return users+authorities;
    707714    }
    708715
    … …  
    850857    }
    851858
    852     @Override
    853     public Principal createPrincipalRecord(String remoteID) {
    854         return principalDao.createShibbolizedPrincipal(remoteID);
    855     }
     859 
    856860
    857861    //// priveee ///

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcPrincipalDao.java

    r4909 r4995  
    1818package eu.dasish.annotation.backend.dao.impl;
    1919
     20import eu.dasish.annotation.backend.Helpers;
    2021import eu.dasish.annotation.backend.NotInDataBaseException;
    2122import eu.dasish.annotation.backend.PrincipalCannotBeDeleted;
    … …  
    103104
    104105    @Override
    105     public boolean principalExists(Principal principal) {
    106 
    107         String emailCriterion = principal.getEMail().toLowerCase();
     106    public boolean principalExists(String remoteID) {
     107
    108108        StringBuilder sqlTargets = new StringBuilder("SELECT ");
    109         sqlTargets.append(principal_id).append(" FROM ").append(principalTableName).append(" WHERE ").append("LOWER(").append(e_mail).append(")= ? LIMIT 1");
    110         List<Number> result = this.loggedQuery(sqlTargets.toString(), internalIDRowMapper, emailCriterion);
     109        sqlTargets.append(principal_id).append(" FROM ").append(principalTableName).append(" WHERE ").append(remote_id).append("= ? LIMIT 1");
     110        List<Number> result = this.loggedQuery(sqlTargets.toString(), internalIDRowMapper, remoteID);
    111111        if (result.size() > 0) {
    112112            return true;
    … …  
    198198        return getInternalID(externalIdentifier);
    199199    }
     200   
     201    @Override
     202    public int addSpringUser(String username, String password, int strength, String salt){
     203       Map<String, Object> params = new HashMap<String, Object>();
     204        params.put("username", username);
     205        params.put("password", Helpers.hashPswd(password, strength, salt));
     206        StringBuilder sql = new StringBuilder("INSERT INTO ");
     207        sql.append(springUserTableName).append("(").append(springUsername).append(",").
     208                append(springPassword).append(") VALUES (:username, :password)");
     209        final int affectedRows = this.loggedUpdate(sql.toString(), params);
     210        return affectedRows;
     211    }
     212   
     213    @Override
     214     public int addSpringAuthorities(String username){
     215        Map<String, Object> params = new HashMap<String, Object>();
     216        params.put("username", username);
     217        StringBuilder sql = new StringBuilder("INSERT INTO ");
     218        sql.append(springAuthoritiesTableName).append("(").append(springUsername).append(") VALUES (:username)");
     219        final int affectedRows = this.loggedUpdate(sql.toString(), params);
     220        return affectedRows; 
     221    }
    200222
    201223    ////////// UPDATERS ///////////////////////
    … …  
    232254    }
    233255
    234     @Override
    235     public Principal createShibbolizedPrincipal(String remoteID) {
    236         Principal result = new Principal();
    237         result.setDisplayName(remoteID);
    238         result.setEMail(remoteID);
    239         return result;
    240     }
     256   
    241257
    242258    ////// DELETERS ////////////

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcResourceDao.java

    r4941 r4995  
    5050    final static protected String versionTableName = "version";
    5151    final static protected String principalTableName = "principal";
     52    final static protected String springUserTableName = "users";
     53    final static protected String springAuthoritiesTableName = "authorities";
    5254    // joint tablenames
    5355    final static protected String notebooksAnnotationsTableName = "notebooks_annotations";
    … …  
    5759    final static protected String targetsCachedRepresentationsTableName = "targets_cached_representations";
    5860    // base string constants: field Names
     61    final static protected String springUsername = "username";
     62    final static protected String springPassword = "password";
    5963    final static protected String account = "account";
    6064    final static protected String admin = "admin";

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/AutheticationResource.java

    r4985 r4995  
    7575        httpServletResponse.sendRedirect(context.getInitParameter("eu.dasish.annotation.backend.logout"));
    7676    }
     77   
     78   
    7779}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/PrincipalResource.java

    r4969 r4995  
    138138
    139139    @POST
     140    @Produces(MediaType.TEXT_PLAIN)
     141    @Path("create/{remoteId}/{password}")
     142    public String createSpringAuthenticationRecord(@PathParam("remoteId") String remoteId, @PathParam("password") String password) throws IOException {
     143        int result = dbIntegrityService.addSpringUser(remoteId, password, 512, remoteId);
     144        return result+ " record(s) has been added. Must be 2: 1 record for the principal, another for the authorities table.";
     145    }
     146
     147    @POST
    140148    @Consumes(MediaType.APPLICATION_XML)
    141149    @Produces(MediaType.APPLICATION_XML)
    … …  
    251259                    loggerServer.debug(e2.toString());;
    252260                    httpServletResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e2.toString());
    253                     return "Nothis is deleted.";
     261                    return "Nothing is deleted.";
    254262                }
    255263            } catch (NotInDataBaseException e) {

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/ResourceResource.java

    r4985 r4995  
    1818package eu.dasish.annotation.backend.rest;
    1919
     20import eu.dasish.annotation.backend.Helpers;
    2021import eu.dasish.annotation.backend.NotInDataBaseException;
    2122import eu.dasish.annotation.backend.PrincipalExists;
    2223import eu.dasish.annotation.backend.dao.DBIntegrityService;
     24import eu.dasish.annotation.schema.Principal;
    2325import java.io.IOException;
    2426import javax.servlet.ServletContext;
    … …  
    7072                    try {
    7173                        try {
    72                             return dbIntegrityService.addPrincipal(dbIntegrityService.createPrincipalRecord(remotePrincipal), remotePrincipal);
     74                            Principal newPrincipal = Helpers.createPrincipalElement(remotePrincipal, remotePrincipal);
     75                            return dbIntegrityService.addPrincipal(newPrincipal, remotePrincipal);
    7376                        } catch (PrincipalExists e2) {
    7477                            loggerServer.info(e2.toString());

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/resources/spring-config/springSecurity.xml

    r4985 r4995  
    2121
    2222<beans xmlns="http://www.springframework.org/schema/beans"
    23     xmlns:security="http://www.springframework.org/schema/security"
    24     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    25     xsi:schemaLocation="http://www.springframework.org/schema/beans
     23       xmlns:security="http://www.springframework.org/schema/security"
     24       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     25       xsi:schemaLocation="http://www.springframework.org/schema/beans
    2626    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    2727    http://www.springframework.org/schema/security
    2828    http://www.springframework.org/schema/security/spring-security-3.2.xsd">     
    29     <security:http auto-config='true'>
     29   
     30    <bean id="passwordEncoderBean" class="org.springframework.security.authentication.encoding.ShaPasswordEncoder">
     31        <constructor-arg value="512" />
     32    </bean>
     33   
     34    <security:http>
    3035        <security:intercept-url pattern="/api/authentication/login" access="ROLE_USER" />
    3136        <security:http-basic />
    3237        <security:logout delete-cookies="JSESSIONID"/>
    3338    </security:http>
     39   
    3440    <security:authentication-manager>
    3541        <security:authentication-provider>
    36             <security:user-service>
    37                 <security:user name="olhsha" password="olhapassword" authorities="ROLE_USER, ROLE_ADMIN" />
    38             </security:user-service>
     42            <security:password-encoder ref="passwordEncoderBean">
     43                <security:salt-source user-property="username"/>
     44            </security:password-encoder>
     45            <security:jdbc-user-service data-source-ref="dataSource"/>
    3946        </security:authentication-provider>
    40     </security:authentication-manager>   
     47    </security:authentication-manager>
     48     
    4149</beans>
    4250

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceTest.java

    r4887 r4995  
    879879        mockeryDao.checking(new Expectations() {
    880880            {
    881                 oneOf(principalDao).principalExists(freshPrincipal);
     881                oneOf(principalDao).principalExists("guisil@mpi.nl");
    882882                will(returnValue(false));
    883883
    … …  
    896896        mockeryDao.checking(new Expectations() {
    897897            {
    898                 oneOf(principalDao).principalExists(principal);
     898                oneOf(principalDao).principalExists("olhsha@mpi.nl");
    899899                will(returnValue(true));
    900900

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcPrincipalDaoTest.java

    r4909 r4995  
    1818package eu.dasish.annotation.backend.dao.impl;
    1919
     20import eu.dasish.annotation.backend.Helpers;
    2021import eu.dasish.annotation.backend.NotInDataBaseException;
    2122import eu.dasish.annotation.backend.PrincipalCannotBeDeleted;
    … …  
    152153    public void tesPrincipalExists() {
    153154        System.out.println("test principalExists");
    154         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
    155 
    156         Principal freshPrincipal = new Principal();
    157         freshPrincipal.setDisplayName("Guilherme");
    158         freshPrincipal.setEMail("guisil@mpi.nl");
    159         assertEquals(false,jdbcPrincipalDao.principalExists(freshPrincipal));
    160 
    161         Principal principal = new Principal();
    162         principal.setDisplayName("Olha");
    163         principal.setEMail("Olha.Shakaravska@mpi.nl");
    164         assertTrue(jdbcPrincipalDao.principalExists(principal));
     155        //jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);       
     156        assertEquals(false,jdbcPrincipalDao.principalExists("guisil@mpi.nl"));       
     157        assertTrue(jdbcPrincipalDao.principalExists("olhsha@mpi.nl"));
    165158    }
    166159   
    … …  
    178171    }
    179172   
    180     @Test
    181     public void testCreateShibbolizedPrincipal(){
    182         System.out.println("test createShibbolizedPrincipal");
    183         Principal result = jdbcPrincipalDao.createShibbolizedPrincipal("test.user@mail.com");
    184         assertEquals("test.user@mail.com", result.getDisplayName());
    185         assertEquals("test.user@mail.com", result.getEMail());
     173   @Test
     174   public void generateHashes() {
     175        System.out.println("*****");
     176        System.out.println("generate hashes");
     177        System.out.println(Helpers.hashPswd("1234", 512, "olhsha@mpi.nl"));
     178        System.out.println(Helpers.hashPswd("5678", 512, "olasei@mpi.nl"));
     179        System.out.println("*****");
     180       
    186181    }
    187182
Note: See TracChangeset for help on using the changeset viewer.