Changeset 5138


Ignore:
Timestamp:
05/06/14 15:32:03 (10 years ago)
Author:
olhsha@mpi.nl
Message:

URL-encoding bug fixing

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r4995 r5138  
    1818package eu.dasish.annotation.backend;
    1919
     20import org.springframework.dao.DuplicateKeyException;
     21
    2022/**
    2123 *
    … …  
    2830    }
    2931   
     32     public PrincipalExists(DuplicateKeyException e){
     33        super(e);
     34    }
     35   
    3036}

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

    r5086 r5138  
    5858    public List<Number> getAnnotationIDsForPublicAccess(Access access);
    5959   
    60    
    61     public List<Number> getAnnotationIDsForTargets(List<Number> TargetIDs);   
    62    
     60   
    6361    /*
    6462     * Use inly in the debugging mode to acces all the existing annotations.
    … …  
    104102     */
    105103    public Access  getAccess(Number annotationID, Number principalID);
     104   
    106105   
    107106    public Access getPublicAttribute(Number annotationID);

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

    r4941 r5138  
    5858    public Map<Number, String> getCachedRepresentationFragmentPairs(Number targetID);
    5959
    60     /**
    61      *
    62      * @param subword
    63      * @return the list of Target ID's which link-fields contain "subword" as a
    64      * substring.
    65      */
    66     public List<Number> getTargetsReferringTo(String subword);
     60   
    6761
    6862    /**
    … …  
    8276    boolean cachedIsInUse(Number cachedID);
    8377
    84     public List<Number> retrieveTargetIDs(Number annotationID);
     78    public List<Number> getTargetIDs(Number annotationID);
    8579
    8680    /**

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

    r5122 r5138  
    5656import java.io.IOException;
    5757import java.io.InputStream;
     58import java.io.UnsupportedEncodingException;
    5859import java.lang.Number;
     60import java.net.URLEncoder;
    5961import java.util.ArrayList;
    6062import java.util.HashMap;
    … …  
    137139        Annotation result = annotationDao.getAnnotationWithoutTargetsAndPemissions(annotationID);
    138140        result.setOwnerRef(principalDao.getURIFromInternalID(annotationDao.getOwner(annotationID)));
    139         List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
     141        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    140142        TargetInfoList sis = new TargetInfoList();
    141143        for (Number targetID : targetIDs) {
    … …  
    180182////////////////////////////////////////////////////////////////////////
    181183    @Override
    182     public List<Number> getFilteredAnnotationIDs(UUID ownerId, String link, String text, Number inloggedPrincipalID, String accessMode, String namespace, String after, String before) throws NotInDataBaseException {
     184    public List<Number> getFilteredAnnotationIDs(UUID ownerId, String linkSubstring, String text, Number inloggedPrincipalID, String accessMode, String namespace, String after, String before) throws NotInDataBaseException {
    183185
    184186        Number ownerID;
    … …  
    187189            if (accessMode.equals("owner")) {
    188190                if (!ownerId.equals(principalDao.getExternalID(inloggedPrincipalID))) {
    189                     logger.debug("The inlogged principal is demanded to be the owner of the annotations, however the expected owner is different and has the UUID " + ownerId.toString());
     191                    logger.info("The inlogged principal is demanded to be the owner of the annotations, however the expected owner is different and has the UUID " + ownerId.toString());
    190192                    return new ArrayList<Number>();
    191193                } else {
    … …  
    205207
    206208
    207 
     209        //Filtering on the columns  of the annotation table
    208210        List<Number> annotationIDs = annotationDao.getFilteredAnnotationIDs(ownerID, text, namespace, after, before);
    209211
    210         //filtering on tables "target" and "annotations_targets"
    211         if (link != null) {
    212             List<Number> targetIDs = targetDao.getTargetsReferringTo(link);
    213             List<Number> annotationIDsForTargets = annotationDao.getAnnotationIDsForTargets(targetIDs);
    214             annotationIDs.retainAll(annotationIDsForTargets);
    215         };
    216 
    217         if (!accessMode.equals("owner")) {
    218             Access access = Access.fromValue(accessMode);
    219             List<Number> annotationIDsAccess = annotationDao.getAnnotationIDsForPermission(inloggedPrincipalID, access);
    220             List<Number> annotationIDsPublic = annotationDao.getAnnotationIDsForPublicAccess(access);
    221             if (accessMode.equals("read")) {
    222                 List<Number> writeIDs = annotationDao.getAnnotationIDsForPermission(inloggedPrincipalID, Access.WRITE);
    223                 annotationIDsAccess.addAll(writeIDs);
    224                 List<Number> writeIDsPublic = annotationDao.getAnnotationIDsForPublicAccess(Access.WRITE);
    225                 annotationIDsPublic.addAll(writeIDsPublic);
    226             }
    227             int check = this.addAllNoRepetitions(annotationIDsAccess, annotationIDsPublic);
    228             List<Number> ownedAnnotIDs = annotationDao.getFilteredAnnotationIDs(inloggedPrincipalID, null, null, null, null);
    229             boolean checkTwo = annotationIDsAccess.addAll(ownedAnnotIDs);
    230             annotationIDs.retainAll(annotationIDsAccess);
     212
     213        // Filetring on accessMode
     214        if (annotationIDs != null) {
     215            if (!annotationIDs.isEmpty()) {
     216                if (!accessMode.equals("owner")) {
     217                    Access access = Access.fromValue(accessMode);
     218                    List<Number> annotationIDsAccess = annotationDao.getAnnotationIDsForPermission(inloggedPrincipalID, access);
     219                    List<Number> annotationIDsPublic = annotationDao.getAnnotationIDsForPublicAccess(access);
     220                    List<Number> annotationIDsOwned = annotationDao.getFilteredAnnotationIDs(inloggedPrincipalID, null, null, null, null);
     221                    int check1 = this.addAllNoRepetitions(annotationIDsAccess, annotationIDsPublic);
     222                    int check2 = this.addAllNoRepetitions(annotationIDsAccess, annotationIDsOwned);
     223                    annotationIDs.retainAll(annotationIDsAccess);
     224                }
     225            }
     226
     227            // filtering on reference       
     228            return this.filterAnnotationIDsOnReference(annotationIDs, linkSubstring);
    231229        }
    232230
    233231        return annotationIDs;
    234     }
    235 
    236     /// helper ///
     232
     233    }
     234
     235    /// helpers ///
     236    private List<Number> filterAnnotationIDsOnReference(List<Number> annotationIDs, String linkSubstring) {
     237        if (linkSubstring != null) {
     238            if (!linkSubstring.isEmpty()) {
     239                if (annotationIDs != null) {
     240                    List<Number> result = new ArrayList();
     241                    for (Number annotationID : annotationIDs) {
     242                        List<Number> targets = targetDao.getTargetIDs(annotationID);
     243                        for (Number targetID : targets) {
     244                            if (!result.contains(annotationID)) {
     245                                String link = targetDao.getLink(targetID);
     246                                if (link.contains(linkSubstring)) {
     247                                    result.add(annotationID);
     248                                } else {
     249                                    try {
     250                                        String urlEncoded = URLEncoder.encode(linkSubstring, "UTF-8");
     251                                        if (link.contains(urlEncoded)) {
     252                                            result.add(annotationID);
     253                                        }
     254                                    } catch (UnsupportedEncodingException e) {
     255                                    }
     256                                }
     257                            }
     258                        }
     259                    }
     260                    return result;
     261                }
     262            }
     263        }
     264        return annotationIDs;
     265    }
     266
    237267    public int addAllNoRepetitions(List<Number> list, List<Number> listToAdd) {
    238268        int result = 0;
    … …  
    259289    public ReferenceList getAnnotationTargets(Number annotationID) {
    260290        ReferenceList result = new ReferenceList();
    261         List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
     291        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    262292        for (Number targetID : targetIDs) {
    263293            result.getRef().add(targetDao.getURIFromInternalID(targetID));
    … …  
    270300
    271301        List<String> result = new ArrayList<String>();
    272         List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
     302        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    273303        for (Number targetID : targetIDs) {
    274304            List<Number> versions = cachedRepresentationDao.getCachedRepresentationsForTarget(targetID);
    … …  
    390420                    return Access.READ;
    391421                } else {
    392                    return access;
     422                    return access;
    393423                }
    394424            } else {
    … …  
    427457                    return true;
    428458                }
    429                 String access = this.getAccess(resourceID, principalID).name();
    430                 String actionName = action.name();
    431                 return access.equals(actionName);
     459                Access access = this.getAccess(resourceID, principalID);
     460                return this.greaterOrEqual(access, action);
    432461            }
    433462            case CACHED_REPRESENTATION: {
    … …  
    444473        }
    445474
     475    }
     476
     477    private boolean greaterOrEqual(Access access, ResourceAction action) {
     478        if (access.equals(Access.WRITE) && (action.equals(ResourceAction.READ) || action.equals(ResourceAction.WRITE))) {
     479            return true;
     480        }
     481        if (access.equals(Access.READ) && action.equals(ResourceAction.READ)) {
     482            return true;
     483        }
     484        return false;
    446485    }
    447486////// noetbooks ///////
    … …  
    623662        return annotationDao.updateAnnotationBody(internalID, body[0], body[1], annotationBody.getXmlBody() != null);
    624663    }
    625    
     664
    626665    @Override
    627666    public int updateAnnotationHeadline(Number internalID, String newHeader) {
    … …  
    789828        int[] result = new int[5];
    790829        result[1] = annotationDao.deleteAnnotationPermissions(annotationID);
    791         List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
     830        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    792831        result[2] = annotationDao.deleteAllAnnotationTarget(annotationID);
    793832        result[3] = 0;

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

    r5086 r5138  
    9999        }
    100100    };
     101   
     102   
    101103
    102104    /////////////////////////////////////////////////////////////////////
    … …  
    174176    }
    175177
    176     //////////////////////////////
    177     @Override
    178     public List<Number> getAnnotationIDsForTargets(List<Number> targetIDs) {
    179 
    180         if (targetIDs.isEmpty()) {
    181             return new ArrayList<Number>();
    182         }
    183         String values = makeListOfValues(targetIDs);
    184         StringBuilder query = new StringBuilder("SELECT DISTINCT ");
    185         query.append(annotation_id).append(" FROM ").append(annotationsTargetsTableName).append(" WHERE ").append(target_id).append(" IN ");
    186         query.append(values);
    187         return this.loggedQuery(query.toString(), internalIDRowMapper);
    188     }
     178   
    189179
    190180    /////////////////////////////////////////

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

    r4941 r5138  
    2222import eu.dasish.annotation.schema.Target;
    2323import eu.dasish.annotation.schema.TargetInfo;
     24import java.io.UnsupportedEncodingException;
     25import java.net.URLEncoder;
    2426import java.sql.ResultSet;
    2527import java.sql.SQLException;
    … …  
    3032import java.util.UUID;
    3133import javax.sql.DataSource;
    32 import javax.xml.datatype.DatatypeConfigurationException;
    3334import javax.xml.datatype.XMLGregorianCalendar;
    3435import org.slf4j.Logger;
    … …  
    4344
    4445    private final Logger loggerTargetDao = LoggerFactory.getLogger(JdbcTargetDao.class);
     46    private final String encoding = "ISO-8859-1";
    4547
    4648    public JdbcTargetDao(DataSource dataTarget) {
    … …  
    7476
    7577    @Override
    76     public String getLink(Number internalID){
     78    public String getLink(Number internalID) {
    7779        StringBuilder sql = new StringBuilder("SELECT ");
    7880        sql.append(targetStar).append(" FROM ").append(targetTableName).append(" WHERE ").append(target_id).append("= ? LIMIT 1");
    … …  
    134136    };
    135137
    136     /////////////////////////////////////////////////////
    137     @Override
    138     public List<Number> getTargetsReferringTo(String word) {
    139         if (word == null) {
    140             loggerTargetDao.debug("word: " + nullArgument);
    141             return new ArrayList<Number>();
    142         }
    143         String searchTerm = "%" + word + "%";
    144         StringBuilder sql = new StringBuilder("SELECT ");
    145         sql.append(target_id).append(" FROM ").append(targetTableName).append(" WHERE ").append(link_uri).append(" LIKE ? ");
    146         return this.loggedQuery(sql.toString(), internalIDRowMapper, searchTerm);
    147     }
    148 
     138   
    149139    /////////////////////////////////////////////////////
    150140    @Override
    … …  
    175165
    176166    @Override
    177     public List<Number> retrieveTargetIDs(Number annotationID) {
     167    public List<Number> getTargetIDs(Number annotationID) {
    178168        StringBuilder sql = new StringBuilder("SELECT DISTINCT ");
    179169        sql.append(target_id).append(" FROM ").append(annotationsTargetsTableName).append(" WHERE ").append(annotation_id).append("= ?");
    … …  
    181171
    182172    }
    183    
     173
    184174    //////// UPDATERS //////////
    185175    @Override
    186     public int updateTargetCachedRepresentationFragment(Number targetID, Number cachedID, String fragmentDescription){
    187 
    188     Map<String, Object> params = new HashMap<String, Object>();
     176    public int updateTargetCachedRepresentationFragment(Number targetID, Number cachedID, String fragmentDescription) {
     177
     178        Map<String, Object> params = new HashMap<String, Object>();
    189179        params.put("targetID", targetID);
    190180        params.put("cachedID", cachedID);
    … …  
    199189    ///////////////////////// ADDERS /////////////////////////////////
    200190    @Override
    201     public Number addTarget(Target target) throws NotInDataBaseException{
     191    public Number addTarget(Target target) throws NotInDataBaseException {
    202192
    203193        UUID externalID = UUID.randomUUID();
    … …  
    217207    @Override
    218208    public int addTargetCachedRepresentation(Number targetID, Number cachedID, String fragmentDescriptor) {
    219      
     209
    220210        Map<String, Object> paramsJoint = new HashMap<String, Object>();
    221211        paramsJoint.put("targetId", targetID);
    … …  
    229219    @Override
    230220    public int deleteTarget(Number internalID) {
    231      
     221
    232222        StringBuilder sqlTargetsVersions = new StringBuilder("DELETE FROM ");
    233223        sqlTargetsVersions.append(targetTableName).append(" WHERE ").append(target_id).append(" = ? ");

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

    r5088 r5138  
    4747import javax.xml.bind.JAXBElement;
    4848import javax.xml.parsers.ParserConfigurationException;
     49import org.springframework.dao.DuplicateKeyException;
    4950import org.springframework.stereotype.Component;
    5051import org.springframework.transaction.annotation.Transactional;
    … …  
    7879        return (result != null) ? (new ObjectFactory().createPrincipal(result)) : (new ObjectFactory().createPrincipal(new Principal()));
    7980    }
    80    
    81       private class GetPrincipal implements ILambda<Map, Principal> {
     81
     82    private class GetPrincipal implements ILambda<Map, Principal> {
    8283
    8384        @Override
    … …  
    8788        }
    8889    }
    89      
    90      /////////////////////////////////
    91 
     90
     91    /////////////////////////////////
    9292    @GET
    9393    @Produces(MediaType.TEXT_PLAIN)
    … …  
    101101        return "The admin of the server database " + dbDispatcher.getDataBaseAdmin().getDisplayName() + " is availiable via e-mail " + dbDispatcher.getDataBaseAdmin().getEMail();
    102102    }
    103    
    104    /////////////////////////////////////////
     103
     104    /////////////////////////////////////////
    105105    @GET
    106106    @Produces(MediaType.TEXT_XML)
    … …  
    113113        return (result != null) ? (new ObjectFactory().createPrincipal(result)) : (new ObjectFactory().createPrincipal(new Principal()));
    114114    }
    115 
    116115
    117116    private class GetPrincipalByInfo implements ILambda<Map, Principal> {
    … …  
    135134        return (result != null) ? (new ObjectFactory().createCurrentPrincipalInfo(result)) : (new ObjectFactory().createCurrentPrincipalInfo(new CurrentPrincipalInfo()));
    136135    }
    137    
    138      private class GetCurrentPrincipalInfo implements ILambda<Map, CurrentPrincipalInfo> {
     136
     137    private class GetCurrentPrincipalInfo implements ILambda<Map, CurrentPrincipalInfo> {
    139138
    140139        @Override
    … …  
    159158
    160159        if (dbDispatcher.getTypeOfPrincipalAccount(remotePrincipalID).equals(admin)) {
    161             int result = dbDispatcher.addSpringUser(remoteId, password, shaStrength, remoteId);
    162             return result + " record(s) has been added. Must be 2: 1 record for the principal, another for the authorities table.";
     160            try {
     161                int result = dbDispatcher.addSpringUser(remoteId, password, shaStrength, remoteId);
     162                return result + " record(s) has been added. Must be 2: 1 record for the principal, another for the authorities table.";
     163            } catch (DuplicateKeyException e) {
     164                loggerServer.error(e.toString());
     165                httpServletResponse.sendError(HttpServletResponse.SC_BAD_REQUEST);
     166                return e.toString();
     167            }
    163168        } else {
    164169            this.ADMIN_RIGHTS_EXPECTED();
    … …  
    168173
    169174    }
    170    
     175
    171176    ///////////////////////////////////////
    172 
    173177    @POST
    174178    @Consumes(MediaType.APPLICATION_XML)
    … …  
    195199
    196200    }
    197    
    198       private class AddPrincipal implements ILambdaPrincipal<Map, Principal> {
     201
     202    private class AddPrincipal implements ILambdaPrincipal<Map, Principal> {
    199203
    200204        @Override
    … …  
    205209    }
    206210
    207    
    208    /////////////////////////////////////
    209 
     211    /////////////////////////////////////
    210212    @POST
    211213    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    … …  
    228230        return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new RegisterNonShibbolizedPrincipal());
    229231    }
    230    
     232
    231233    private class RegisterNonShibbolizedPrincipal implements ILambdaPrincipal<Map, Principal> {
    232234
    233235        @Override
    234236        public Principal apply(Map params) throws NotInDataBaseException, PrincipalExists {
    235             final int updatedSpringTables = dbDispatcher.addSpringUser((String) params.get("remoteId"), (String) params.get("password"), (Integer) params.get("shaStrength"), (String) params.get("remoteId"));
    236             final Number principalID = dbDispatcher.addPrincipal((Principal) params.get("newPrincipal"), (String) params.get("remoteId"));
    237             return dbDispatcher.getPrincipal(principalID);
    238         }
    239     }
    240 
    241  
    242    ///////////////////////////////////////////////
    243 
     237            try {
     238                final int updatedSpringTables = dbDispatcher.addSpringUser((String) params.get("remoteId"), (String) params.get("password"), (Integer) params.get("shaStrength"), (String) params.get("remoteId"));
     239                final Number principalID = dbDispatcher.addPrincipal((Principal) params.get("newPrincipal"), (String) params.get("remoteId"));
     240                return dbDispatcher.getPrincipal(principalID);
     241            } catch (DuplicateKeyException e) {
     242                throw new PrincipalExists(e);
     243            }
     244        }
     245    }
     246
     247    ///////////////////////////////////////////////
    244248    @POST
    245249    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    … …  
    260264        return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new AddPrincipal());
    261265    }
    262    
     266
    263267    ///////////////////////////////////////////////////
    264 
    265268    @POST
    266269    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    … …  
    269272    public String registerShibbolizedPrincipalAsNonShibb(@FormParam("remoteId") String remoteId, @FormParam("password") String password)
    270273            throws IOException {
    271         int result = dbDispatcher.addSpringUser(remoteId, password, shaStrength, remoteId);
    272         return result + " record(s) has been added. Must be 2: 1 record for the principal, another for the authorities table.";
    273 
     274        try {
     275            int result = dbDispatcher.addSpringUser(remoteId, password, shaStrength, remoteId);
     276            return result + " record(s) has been added. Must be 2: 1 record for the principal, another for the authorities table.";
     277        } catch (DuplicateKeyException e) {
     278            loggerServer.error(e.toString());
     279            httpServletResponse.sendError(HttpServletResponse.SC_BAD_REQUEST);
     280            return e.toString();
     281        }
    274282    }
    275283
    … …  
    303311    public JAXBElement<Principal> updatePrincipalFromForm(@FormParam("name") String name, @FormParam("email") String email)
    304312            throws IOException {
    305        
     313
    306314        Principal newPrincipal = new Principal();
    307315        newPrincipal.setDisplayName(name);
    … …  
    312320        return (result != null) ? (new ObjectFactory().createPrincipal(result)) : (new ObjectFactory().createPrincipal(new Principal()));
    313321    }
    314    
    315    
    316      private class UpdatePrincipal implements ILambda<Map, Principal> {
     322
     323    private class UpdatePrincipal implements ILambda<Map, Principal> {
     324
    317325        @Override
    318326        public Principal apply(Map params) throws NotInDataBaseException {
    319327            Principal principal = (Principal) params.get("newPrincipal");
    320             Number principalID = (Number) params.get("principalID");           
     328            Number principalID = (Number) params.get("principalID");
    321329            String uri = dbDispatcher.getResourceURI(principalID, Resource.PRINCIPAL);
    322330            principal.setURI(uri);
    … …  
    325333        }
    326334    }
    327      
    328      //////////////////////////////////////
    329 
     335
     336    //////////////////////////////////////
    330337    @PUT
    331338    @Produces(MediaType.TEXT_PLAIN)
    … …  
    394401        return (httpServletRequest.getRemoteUser()).equals(dbDispatcher.getPrincipalRemoteID(principalID));
    395402    }
    396 
    397403}

  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/webapp/index.jsp

    r5022 r5138  
    5151        GET <a href="api/principals/00000000-0000-0000-0000-0000000000112/current">api/principals/00000000-0000-0000-0000-0000000000112/current</a>  !Problem: how to ask the servlet if the given user is logged in, may be by some other running somewhere client<br>
    5252        GET <a href="api/principals/info?email=Twan.Goosen@mpi.nl">api/principals/info?email=Twan.Goosen@mpi.nl</a>  <br>
    53         GET <a href="api/annotations?link=Sagrada">api/annotations?link=Sagrada</a>  <br>
    54         GET <a href="api/annotations?link=Gaud">api/annotations?link=Gaud</a>  <br>
     53        GET <a href="api/annotations?link=Sagrada_Família">api/annotations?link=Sagrada_Família</a>  <br>
     54        GET <a href="api/annotations?link=Antoni_Gaud%C3%AD">api/annotations?link=Antoni_Gaud%C3%AD</a>  <br>
    5555        GET <a href="api/annotations?after=2014-02-04 15:57:58.046908&before=2014-04-06 10:08:16.213186">api/annotations?after=2014-02-04 15:57:58.046908&before=2014-04-06 10:08:16.213186</a>
    5656        !Comment: What is "namespace" query parameter? Must be implemented and tested <br>

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

    r5088 r5138  
    237237                will(returnValue(uri1));
    238238
    239                 oneOf(targetDao).retrieveTargetIDs(1);
     239                oneOf(targetDao).getTargetIDs(1);
    240240                will(returnValue(mockTargetIDs));
    241241
    … …  
    300300    public void testGetFilteredAnnotationIDs() throws NotInDataBaseException {
    301301        System.out.println("test getFilteredAnnotationIDs");
    302 
    303         final List<Number> mockTargetIDs = new ArrayList<Number>();
    304         mockTargetIDs.add(1);
    305         mockTargetIDs.add(2);
    306 
     302       
    307303        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    308304        mockAnnotationIDs1.add(1);
    309 
    310         final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
    311         mockAnnotationIDs2.add(1);
    312         mockAnnotationIDs2.add(2);
    313 
    314 
     305     
    315306        final List<Number> mockAnnotationIDsOwned = new ArrayList<Number>();
    316307        mockAnnotationIDsOwned.add(3);
    … …  
    318309        final List<Number> mockAnnotationIDsRead = new ArrayList<Number>();
    319310        mockAnnotationIDsRead.add(1);
     311        mockAnnotationIDsRead.add(2);
     312       
     313
     314        final List<Number> mockAnnotationIDsPublicRead = new ArrayList<Number>();
     315        mockAnnotationIDsPublicRead.add(1);
     316        mockAnnotationIDsPublicRead.add(2);
     317       
     318        final List<Number> mockTargets1 = new ArrayList<Number>();
     319        mockTargets1.add(1);
     320        mockTargets1.add(2);
     321       
     322       
     323        final String link1 = "http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia";
     324        final String link2 = "http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD";
     325
     326        final String after = (new Timestamp(0)).toString();
     327        final String before = (new Timestamp(System.currentTimeMillis())).toString();
     328
     329        final Number loggedIn = 3;
     330
     331        mockeryDao.checking(new Expectations() {
     332            {
     333               
     334
     335                oneOf(annotationDao).getFilteredAnnotationIDs(null, "some html 1", null, after, before);
     336                will(returnValue(mockAnnotationIDs1));
     337
     338                oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.READ);
     339                will(returnValue(mockAnnotationIDsRead));
     340
     341                oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.READ);
     342                will(returnValue(mockAnnotationIDsPublicRead));               
     343
     344                oneOf(annotationDao).getFilteredAnnotationIDs(loggedIn, null, null, null, null);
     345                will(returnValue(mockAnnotationIDsOwned));
     346               
     347                oneOf(targetDao).getTargetIDs(1);
     348                will(returnValue(mockTargets1));
     349               
     350                oneOf(targetDao).getLink(1);
     351                will(returnValue(link1));
     352               
     353                oneOf(targetDao).getLink(2);
     354                will(returnValue(link2));
     355             
     356
     357            }
     358        });
     359
     360
     361        List result = dbDispatcher.getFilteredAnnotationIDs(null, "Sagrada_Fam%C3%ADlia", "some html 1", 3, "read", null, after, before);
     362        assertEquals(1, result.size());
     363        assertEquals(1, result.get(0));
     364    }
     365
     366    @Test
     367    public void testGetFilteredAnnotationIDs2() throws NotInDataBaseException {
     368        System.out.println("test getFilteredAnnotationIDs");
     369
     370       
     371        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
     372        mockAnnotationIDs1.add(1);
     373
     374     
     375        final List<Number> mockAnnotationIDsOwned = new ArrayList<Number>();
     376        mockAnnotationIDsOwned.add(3);
    320377
    321378        final List<Number> mockAnnotationIDsWrite = new ArrayList<Number>();
    322379        mockAnnotationIDsWrite.add(2);
    323 
    324         final List<Number> mockAnnotationIDsPublicRead = new ArrayList<Number>();
    325         mockAnnotationIDsRead.add(2);
     380       
    326381
    327382        final List<Number> mockAnnotationIDsPublicWrite = new ArrayList<Number>();
    328         mockAnnotationIDsWrite.add(1);
     383        mockAnnotationIDsPublicWrite.add(1);
     384       
     385        final List<Number> mockTargets1 = new ArrayList<Number>();
     386        mockTargets1.add(1);
     387        mockTargets1.add(2);
     388       
     389       
     390        final String link1 = "http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia";
     391        final String link2 = "http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD";
    329392
    330393        final String after = (new Timestamp(0)).toString();
    331394        final String before = (new Timestamp(System.currentTimeMillis())).toString();
    332395
    333 //        final List<Number> mockRetval = new ArrayList<Number>();
    334 //        mockRetval.add(1);
    335 
    336396        final Number loggedIn = 3;
    337397
    338398        mockeryDao.checking(new Expectations() {
    339399            {
    340                 oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    341                 will(returnValue(mockTargetIDs));
    342 
    343                 oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
    344                 will(returnValue(mockAnnotationIDs2));
     400               
    345401
    346402                oneOf(annotationDao).getFilteredAnnotationIDs(null, "some html 1", null, after, before);
    347403                will(returnValue(mockAnnotationIDs1));
    348404
    349                 oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.READ);
    350                 will(returnValue(mockAnnotationIDsRead));
    351 
    352                 oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.READ);
    353                 will(returnValue(mockAnnotationIDsPublicRead));
    354 
    355405                oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.WRITE);
    356406                will(returnValue(mockAnnotationIDsWrite));
    357407
    358408                oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.WRITE);
    359                 will(returnValue(mockAnnotationIDsPublicWrite));
     409                will(returnValue(mockAnnotationIDsPublicWrite));               
    360410
    361411                oneOf(annotationDao).getFilteredAnnotationIDs(loggedIn, null, null, null, null);
    362412                will(returnValue(mockAnnotationIDsOwned));
    363 
    364             }
    365         });
    366 
    367 
    368         List result = dbDispatcher.getFilteredAnnotationIDs(null, "nl.wikipedia.org", "some html 1", 3, "read", null, after, before);
     413               
     414                oneOf(targetDao).getTargetIDs(1);
     415                will(returnValue(mockTargets1));
     416               
     417                oneOf(targetDao).getLink(1);
     418                will(returnValue(link1));
     419               
     420                oneOf(targetDao).getLink(2);
     421                will(returnValue(link2));
     422               
     423            }
     424        });
     425
     426
     427        List result = dbDispatcher.getFilteredAnnotationIDs(null, "Sagrada_Fam%C3%ADlia", "some html 1", 3, "write", null, after, before);
    369428        assertEquals(1, result.size());
    370429        assertEquals(1, result.get(0));
    371     }
    372 
    373     @Test
    374     public void testGetFilteredAnnotationIDs2() throws NotInDataBaseException {
     430
     431    }
     432
     433    @Test
     434    public void testGetFilteredAnnotationIDs3() throws NotInDataBaseException {
    375435        System.out.println("test getFilteredAnnotationIDs");
    376436
    377         final List<Number> mockTargetIDs = new ArrayList<Number>();
    378         mockTargetIDs.add(1);
    379         mockTargetIDs.add(2);
    380 
     437       
    381438        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    382         mockAnnotationIDs1.add(1);
    383 
    384         final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
    385         mockAnnotationIDs2.add(1);
    386         mockAnnotationIDs2.add(2);
    387 
    388 
    389         final List<Number> mockAnnotationIDsOwned = new ArrayList<Number>();
    390         mockAnnotationIDsOwned.add(3);
    391 
    392         final List<Number> mockAnnotationIDsRead = new ArrayList<Number>();
    393         mockAnnotationIDsRead.add(1);
    394 
    395         final List<Number> mockAnnotationIDsWrite = new ArrayList<Number>();
    396         mockAnnotationIDsWrite.add(2);
    397 
    398         final List<Number> mockAnnotationIDsPublicRead = new ArrayList<Number>();
    399         mockAnnotationIDsRead.add(2);
    400 
    401         final List<Number> mockAnnotationIDsPublicWrite = new ArrayList<Number>();
    402         mockAnnotationIDsWrite.add(1);
    403 
     439       
    404440        final String after = (new Timestamp(0)).toString();
    405441        final String before = (new Timestamp(System.currentTimeMillis())).toString();
    406442
    407 //        final List<Number> mockRetval = new ArrayList<Number>();
    408 //        mockRetval.add(1);
    409 
    410         final Number loggedIn = 3;
    411 
    412         mockeryDao.checking(new Expectations() {
    413             {
    414                 oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    415                 will(returnValue(mockTargetIDs));
    416 
    417                 oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
    418                 will(returnValue(mockAnnotationIDs2));
    419 
    420                 oneOf(annotationDao).getFilteredAnnotationIDs(null, "some html 1", null, after, before);
     443       
     444        mockeryDao.checking(new Expectations() {
     445            {               
     446
     447                oneOf(annotationDao).getFilteredAnnotationIDs(3, "some html 1", null, after, before);
    421448                will(returnValue(mockAnnotationIDs1));
    422449
    423                 oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.READ);
    424                 will(returnValue(mockAnnotationIDsRead));
    425 
    426                 oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.READ);
    427                 will(returnValue(mockAnnotationIDsPublicRead));
    428 
    429                 oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.WRITE);
    430                 will(returnValue(mockAnnotationIDsWrite));
    431 
    432                 oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.WRITE);
    433                 will(returnValue(mockAnnotationIDsPublicWrite));
    434 
    435                 oneOf(annotationDao).getFilteredAnnotationIDs(loggedIn, null, null, null, null);
    436                 will(returnValue(mockAnnotationIDsOwned));
    437 
    438             }
    439         });
    440 
    441 
    442         List result = dbDispatcher.getFilteredAnnotationIDs(null, "nl.wikipedia.org", "some html 1", 3, "write", null, after, before);
    443         assertEquals(1, result.size());
    444         assertEquals(1, result.get(0));
    445     }
    446 
    447     @Test
    448     public void testGetFilteredAnnotationIDs3() throws NotInDataBaseException {
    449         System.out.println("test getFilteredAnnotationIDs");
    450 
    451         final List<Number> mockTargetIDs = new ArrayList<Number>();
    452         mockTargetIDs.add(1);
    453         mockTargetIDs.add(2);
    454 
    455         final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
    456         mockAnnotationIDs2.add(1);
    457         mockAnnotationIDs2.add(2);
    458 
    459 
    460         final String after = (new Timestamp(0)).toString();
    461         final String before = (new Timestamp(System.currentTimeMillis())).toString();
    462 
    463 //        final List<Number> mockRetval = new ArrayList<Number>();
    464 //        mockRetval.add(1);
    465 
    466         final Number loggedIn = 3;
    467 
    468         mockeryDao.checking(new Expectations() {
    469             {
    470                 oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    471                 will(returnValue(mockTargetIDs));
    472 
    473                 oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
    474                 will(returnValue(mockAnnotationIDs2));
    475 
    476                 oneOf(annotationDao).getFilteredAnnotationIDs(loggedIn, "some html 1", null, after, before);
    477                 will(returnValue(new ArrayList<Number>()));
    478 
    479 
    480             }
    481         });
    482 
    483 
    484         List result = dbDispatcher.getFilteredAnnotationIDs(null, "nl.wikipedia.org", "some html 1", 3, "owner", null, after, before);
     450            }
     451        });
     452
     453
     454        List result = dbDispatcher.getFilteredAnnotationIDs(null, "Sagrada_Fam%C3%ADlia", "some html 1", 3, "owner", null, after, before);
    485455        assertEquals(0, result.size());
    486456    }
    … …  
    490460        System.out.println("test getFilteredAnnotationIDs");
    491461
    492         final List<Number> mockTargetIDs = new ArrayList<Number>();
    493         mockTargetIDs.add(1);
    494         mockTargetIDs.add(2);
    495 
    496         final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
    497         mockAnnotationIDs2.add(1);
    498         mockAnnotationIDs2.add(2);
    499 
     462       
    500463
    501464        final String after = (new Timestamp(0)).toString();
    … …  
    530493        mockeryDao.checking(new Expectations() {
    531494            {
    532                 oneOf(targetDao).retrieveTargetIDs(1);
     495                oneOf(targetDao).getTargetIDs(1);
    533496                will(returnValue(TargetIDs));
    534497
    … …  
    562525        System.out.println("test getetFilteredAnnotationInfos");
    563526
    564         final List<Number> mockTargetIDs = new ArrayList<Number>();
    565         mockTargetIDs.add(1);
    566         mockTargetIDs.add(2);
    567527
    568528        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    569529        mockAnnotationIDs1.add(1);
    570530
    571         final List<Number> mockAnnotationIDs2 = new ArrayList<Number>();
    572         mockAnnotationIDs2.add(1);
    573         mockAnnotationIDs2.add(2);
     531       
    574532
    575533        final UUID ownerUUID = UUID.fromString("00000000-0000-0000-0000-000000000111");
    … …  
    584542        final List<Number> mockAnnotationIDsRead = new ArrayList<Number>();
    585543        mockAnnotationIDsRead.add(1);
    586 
    587         final List<Number> mockAnnotationIDsWrite = new ArrayList<Number>();
    588         mockAnnotationIDsWrite.add(2);
    589 
     544        mockAnnotationIDsRead.add(2);
     545       
    590546        final List<Number> mockAnnotationIDsPublicRead = new ArrayList<Number>();
    591         mockAnnotationIDsRead.add(2);
    592 
    593         final List<Number> mockAnnotationIDsPublicWrite = new ArrayList<Number>();
    594         mockAnnotationIDsWrite.add(1);
     547        mockAnnotationIDsPublicRead.add(1);
     548        mockAnnotationIDsPublicRead.add(2);
     549
     550       
     551       
     552       
     553        final List<Number> mockTargets1 = new ArrayList<Number>();
     554        mockTargets1.add(1);
     555        mockTargets1.add(2);
     556       
     557       
     558        final String link1 = "http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia";
     559        final String link2 = "http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD";
     560       
    595561
    596562        final AnnotationInfo mockAnnotInfo = new AnnotationInfo();
    … …  
    611577                will(returnValue(1));
    612578
    613                 oneOf(targetDao).getTargetsReferringTo("nl.wikipedia.org");
    614                 will(returnValue(mockTargetIDs));
    615 
    616                 oneOf(annotationDao).getAnnotationIDsForTargets(mockTargetIDs);
    617                 will(returnValue(mockAnnotationIDs2));
     579             
    618580
    619581                oneOf(annotationDao).getFilteredAnnotationIDs(1, "some html 1", null, after, before);
    … …  
    625587                oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.READ);
    626588                will(returnValue(mockAnnotationIDsPublicRead));
    627 
    628                 oneOf(annotationDao).getAnnotationIDsForPermission(loggedIn, Access.WRITE);
    629                 will(returnValue(mockAnnotationIDsWrite));
    630 
    631                 oneOf(annotationDao).getAnnotationIDsForPublicAccess(Access.WRITE);
    632                 will(returnValue(mockAnnotationIDsPublicWrite));
     589             
    633590
    634591                oneOf(annotationDao).getFilteredAnnotationIDs(loggedIn, null, null, null, null);
    635592                will(returnValue(mockAnnotationIDsOwned));
    636593
     594                oneOf(targetDao).getTargetIDs(1);
     595                will(returnValue(mockTargets1));
     596               
     597                oneOf(targetDao).getLink(1);
     598                will(returnValue(link1));
     599               
     600                oneOf(targetDao).getLink(2);
     601                will(returnValue(link2));
    637602
    638603//                ///////////////////////////////////
    … …  
    648613
    649614                ////
    650                 oneOf(targetDao).retrieveTargetIDs(1);
     615                oneOf(targetDao).getTargetIDs(1);
    651616                will(returnValue(targetIDs));
    652617
    … …  
    690655        mockeryDao.checking(new Expectations() {
    691656            {
    692                 oneOf(targetDao).retrieveTargetIDs(3);
     657                oneOf(targetDao).getTargetIDs(3);
    693658                will(returnValue(targetIDs));
    694659
    … …  
    1011976                will(returnValue(2));
    1012977
    1013                 oneOf(targetDao).retrieveTargetIDs(2);
     978                oneOf(targetDao).getTargetIDs(2);
    1014979                will(returnValue(mockTargetIDs));
    1015980

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

    r5086 r5138  
    255255    }
    256256
    257     @Test
    258     public void testGetAnnotationIDsForTargets() {
    259         System.out.println("test getAnnotationIDsForTargets");
    260         List<Number> targets = new ArrayList<Number>();
    261         targets.add(1);
    262         targets.add(2);
    263         List<Number> result = jdbcAnnotationDao.getAnnotationIDsForTargets(targets);
    264         assertEquals(2, result.size());
    265         assertEquals(1, result.get(0));
    266         assertEquals(2, result.get(1));
    267     }
     257   
    268258
    269259    //////////////////////////////////

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

    r4941 r5138  
    191191    }
    192192
    193     /**
    194      * test public List<Number> getTargetsForLink(String link)
    195      *
    196      *
    197      */
    198     @Test
    199     public void tesGetTargetsReferringTo() {
    200         System.out.println(" test getTargetsReferringTo");
    201 
    202         String substring = "http://nl.wikipedia.org";
    203         List<Number> result = jdbcTargetDao.getTargetsReferringTo(substring);
    204         assertEquals(2, result.size());
    205         assertEquals(1, result.get(0));
    206         assertEquals(2, result.get(1));
    207     }
     193   
    208194
    209195    @Test
    … …  
    211197        System.out.println("retrieveTargetIDs");
    212198        Number annotationID = 1;
    213         List<Number> result = jdbcTargetDao.retrieveTargetIDs(annotationID);
     199        List<Number> result = jdbcTargetDao.getTargetIDs(annotationID);
    214200        assertEquals(2, result.size());
    215201        assertEquals(1, result.get(0));
Note: See TracChangeset for help on using the changeset viewer.