Changeset 5385 for DASISH


Ignore:
Timestamp:
06/24/14 17:43:30 (10 years ago)
Author:
olhsha@mpi.nl
Message:

ref --> href
+ xml:id for instances
refactoring

Location:
DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend
Files:
3 deleted
34 edited

Legend:

Unmodified
Added
Removed
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/DBDispatcher.java

    r5186 r5385  
    5151public interface DBDispatcher {
    5252
    53     void setServiceURI(String serviceURI);
     53    void setResourcesPaths(String relServiceURI);
    5454
    5555    /**
     
    5959    Number getResourceInternalIdentifier(UUID externalID, Resource resource) throws NotInDataBaseException;
    6060
    61     Number getResourceInternalIdentifierFromURI(String uri, Resource resource) throws NotInDataBaseException;
    62 
    6361    UUID getResourceExternalIdentifier(Number resourceID, Resource resource);
    64 
    65     String getResourceURI(Number resourceID, Resource resource);
    6662
    6763    PermissionList getPermissions(Number resourceID, Resource resource);
     
    179175
    180176    Number getPrincipalInternalIDFromRemoteID(String remoteID) throws NotInDataBaseException;
     177   
     178    UUID getPrincipalExternalIDFromRemoteID(String remoteID) throws NotInDataBaseException;
    181179
    182180    /**
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/PrincipalDao.java

    r5186 r5385  
    5151     public Number getPrincipalInternalIDFromRemoteID(String remoteID) throws NotInDataBaseException;
    5252     
     53     public UUID getPrincipalExternalIDFromRemoteID(String remoteID) throws NotInDataBaseException;
     54     
     55     
    5356     public List<Number> getPrincipalIDsWithAccessForNotebook(Number notebookID, Access access);
    5457     
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/ResourceDao.java

    r5086 r5385  
    3030public interface ResourceDao {
    3131
    32     void setServiceURI(String serviceURI);
     32    void setResourcePath(String relResourcePath);
    3333
    3434    Number getInternalID(UUID externalId) throws NotInDataBaseException;
    3535
    36     Number getInternalIDFromURI(String uri) throws NotInDataBaseException;
    37 
    3836    UUID getExternalID(Number internalId);
    3937
    40     String externalIDtoURI(String externalID);
    41 
    42     /**
    43      *
    44      * @param stringURI
    45      * @return returns the extranlID which is a suffix of stringURI
    46      */
    47     String stringURItoExternalID(String stringURI);
    48 
     38 
     39 
    4940    /**
    5041     *
     
    5344     * with internalID
    5445     */
    55     String getURIFromInternalID(Number internalID);
     46    String getHrefFromInternalID(Number internalID);
     47   
     48    Number getInternalIDFromHref(String href)  throws NotInDataBaseException;
    5649
    5750    List<Map<Number, String>> getPermissions(Number resourceID);
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/TargetDao.java

    r5138 r5385  
    118118    /**
    119119     *
    120      * @param TargetID
     120     * @param targetID
    121121     * @return # deleted rows in the table "Targets_cached_representation" when
    122122     * deleting the pair (TargetID, chachedID)
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/DBDispatcherImlp.java

    r5203 r5385  
    106106
    107107    @Override
    108     public void setServiceURI(String serviceURI) {
    109         principalDao.setServiceURI(serviceURI + "principals/");
    110         cachedRepresentationDao.setServiceURI(serviceURI + "cached/");
    111         targetDao.setServiceURI(serviceURI + "targets/");
    112         annotationDao.setServiceURI(serviceURI + "annotations/");
    113         notebookDao.setServiceURI(serviceURI + "notebooks/");
     108    public void setResourcesPaths(String relServiceURI) {
     109        principalDao.setResourcePath(relServiceURI + "/principals/");
     110        cachedRepresentationDao.setResourcePath(relServiceURI + "/cached/");
     111        targetDao.setResourcePath(relServiceURI + "/targets/");
     112        annotationDao.setResourcePath(relServiceURI + "/annotations/");
     113        notebookDao.setResourcePath(relServiceURI + "/notebooks/");
    114114    }
    115115
     
    120120    }
    121121
    122     @Override
    123     public Number getResourceInternalIdentifierFromURI(String uri, Resource resource) throws NotInDataBaseException {
    124         return this.getDao(resource).getInternalIDFromURI(uri);
    125     }
    126 
     122 
    127123    @Override
    128124    public UUID getResourceExternalIdentifier(Number resourceID, Resource resource) {
     
    130126    }
    131127
    132     @Override
    133     public String getResourceURI(Number resourceID, Resource resource) {
    134         return this.getDao(resource).getURIFromInternalID(resourceID);
    135     }
    136 
     128   
    137129    @Override
    138130    public Annotation getAnnotation(Number annotationID) {
    139131        Annotation result = annotationDao.getAnnotationWithoutTargetsAndPemissions(annotationID);
    140         result.setOwnerRef(principalDao.getURIFromInternalID(annotationDao.getOwner(annotationID)));
     132        result.setOwnerHref(principalDao.getHrefFromInternalID(annotationDao.getOwner(annotationID)));
    141133        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    142134        TargetInfoList sis = new TargetInfoList();
    143135        for (Number targetID : targetIDs) {
    144             TargetInfo targetInfo = getTargetInfoFromTarget(targetDao.getTarget(targetID));
     136            TargetInfo targetInfo = this.getTargetInfoFromTarget(targetDao.getTarget(targetID));
    145137            sis.getTargetInfo().add(targetInfo);
    146138        }
     
    173165            principalAccess.keySet().toArray(principal);
    174166            Permission permission = new Permission();
    175             permission.setPrincipalRef(principalDao.getURIFromInternalID(principal[0]));
     167            permission.setPrincipalHref(principalDao.getHrefFromInternalID(principal[0]));
    176168            permission.setLevel(Access.fromValue(principalAccess.get(principal[0])));
    177169            list.add(permission);
     
    311303        List<Number> targetIDs = targetDao.getTargetIDs(annotationID);
    312304        for (Number targetID : targetIDs) {
    313             result.getRef().add(targetDao.getURIFromInternalID(targetID));
     305            result.getHref().add(targetDao.getHrefFromInternalID(targetID));
    314306        }
    315307        return result;
     
    324316            List<Number> versions = cachedRepresentationDao.getCachedRepresentationsForTarget(targetID);
    325317            if (versions.isEmpty()) {
    326                 result.add(targetDao.getURIFromInternalID(targetID));
     318                result.add(targetDao.getHrefFromInternalID(targetID));
    327319            }
    328320        }
     
    339331            Principal principal = principalDao.getPrincipal(principalID[0]);
    340332            if (principal.getDisplayName() == null || principal.getDisplayName().trim().isEmpty() || principal.getEMail() == null || principal.getEMail().trim().isEmpty()) {
    341                 result.add(principalDao.getURIFromInternalID(principalID[0]));
     333                result.add(principalDao.getHrefFromInternalID(principalID[0]));
    342334
    343335            }
     
    353345            AnnotationInfo annotationInfo = annotationDao.getAnnotationInfoWithoutTargetsAndOwner(annotationID);
    354346            annotationInfo.setTargets(this.getAnnotationTargets(annotationID));
    355             annotationInfo.setOwnerRef(principalDao.getURIFromInternalID(annotationDao.getOwner(annotationID)));
     347            annotationInfo.setOwnerHref(principalDao.getHrefFromInternalID(annotationDao.getOwner(annotationID)));
    356348            result.getAnnotationInfo().add(annotationInfo);
    357349        }
     
    365357        for (Number annotationID : annotationIDs) {
    366358            Number ownerID = annotationDao.getOwner(annotationID);
    367             ReferenceList targets = getAnnotationTargets(annotationID);
     359            ReferenceList targets = this.getAnnotationTargets(annotationID);
    368360            AnnotationInfo annotationInfo = annotationDao.getAnnotationInfoWithoutTargetsAndOwner(annotationID);
    369361            annotationInfo.setTargets(targets);
    370             annotationInfo.setOwnerRef(principalDao.getURIFromInternalID(ownerID));
     362            annotationInfo.setOwnerHref(principalDao.getHrefFromInternalID(ownerID));
    371363            result.getAnnotationInfo().add(annotationInfo);
    372364        }
     
    384376        for (Number key : cachedIDsFragments.keySet()) {
    385377            CachedRepresentationFragment cachedRepresentationFragment = new CachedRepresentationFragment();
    386             cachedRepresentationFragment.setRef(cachedRepresentationDao.getURIFromInternalID(key));
     378            cachedRepresentationFragment.setHref(cachedRepresentationDao.getHrefFromInternalID(key));
    387379            cachedRepresentationFragment.setFragmentString(cachedIDsFragments.get(key));
    388380            cachedRepresentationFragmentList.getCached().add(cachedRepresentationFragment);
     
    409401        ReferenceList referenceList = new ReferenceList();
    410402        for (Number siblingID : targetIDs) {
    411             referenceList.getRef().add(targetDao.externalIDtoURI(targetDao.getExternalID(siblingID).toString()));
     403            referenceList.getHref().add(targetDao.getHrefFromInternalID(siblingID));
    412404        }
    413405        return referenceList;
     
    461453        return principalDao.getPrincipalInternalIDFromRemoteID(remoteID);
    462454    }
     455   
     456    @Override
     457    public UUID getPrincipalExternalIDFromRemoteID(String remoteID) throws NotInDataBaseException {
     458        return principalDao.getPrincipalExternalIDFromRemoteID(remoteID);
     459    }
    463460
    464461    @Override
     
    519516                NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
    520517                Number ownerID = notebookDao.getOwner(notebookID);
    521                 notebookInfo.setOwnerRef(principalDao.getURIFromInternalID(ownerID));
     518                notebookInfo.setOwnerHref(principalDao.getHrefFromInternalID(ownerID));
    522519                result.getNotebookInfo().add(notebookInfo);
    523520            }
     
    537534        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
    538535        for (Number notebookID : notebookIDs) {
    539             String reference = notebookDao.getURIFromInternalID(notebookID);
    540             result.getRef().add(reference);
     536            String reference = notebookDao.getHrefFromInternalID(notebookID);
     537            result.getHref().add(reference);
    541538        }
    542539        return result;
     
    548545        List<Number> principalIDs = principalDao.getPrincipalIDsWithAccessForNotebook(notebookID, Access.fromValue(access));
    549546        for (Number principalID : principalIDs) {
    550             String reference = principalDao.getURIFromInternalID(principalID);
    551             result.getRef().add(reference);
     547            String reference = principalDao.getHrefFromInternalID(principalID);
     548            result.getHref().add(reference);
    552549        }
    553550        return result;
     
    558555        Notebook result = notebookDao.getNotebookWithoutAnnotationsAndAccesssAndOwner(notebookID);
    559556
    560         result.setOwnerRef(principalDao.getURIFromInternalID(notebookDao.getOwner(notebookID)));
     557        result.setOwnerRef(principalDao.getHrefFromInternalID(notebookDao.getOwner(notebookID)));
    561558
    562559        ReferenceList annotations = new ReferenceList();
    563560        List<Number> annotationIDs = annotationDao.getAnnotations(notebookID);
    564561        for (Number annotationID : annotationIDs) {
    565             annotations.getRef().add(annotationDao.getURIFromInternalID(annotationID));
     562            annotations.getHref().add(annotationDao.getHrefFromInternalID(annotationID));
    566563        }
    567564        result.setAnnotations(annotations);
     
    576573                for (Number principal : principals) {
    577574                    Permission up = new Permission();
    578                     up.setPrincipalRef(principalDao.getURIFromInternalID(principal));
     575                    up.setPrincipalHref(principalDao.getHrefFromInternalID(principal));
    579576                    up.setLevel(access);
    580577                    ups.getPermission().add(up);
     
    611608        ReferenceList references = new ReferenceList();
    612609        for (Number annotationID : selectedAnnotIDs) {
    613             references.getRef().add(annotationDao.getURIFromInternalID(annotationID));
     610            references.getHref().add(annotationDao.getHrefFromInternalID(annotationID));
    614611        }
    615612        return references;
     
    649646        int result = 0;
    650647        for (Permission permission : permissions) {
    651             Number principalID = principalDao.getInternalIDFromURI(permission.getPrincipalRef());
     648            Number principalID = principalDao.getInternalIDFromHref(permission.getPrincipalHref());
    652649            Access access = permission.getLevel();
    653650            Access currentAccess = annotationDao.getAccess(annotationID, principalID);
     
    670667    @Override
    671668    public int updateAnnotation(Annotation annotation) throws NotInDataBaseException {
    672         Number annotationID = annotationDao.getInternalIDFromURI(annotation.getURI());
    673         int updatedAnnotations = annotationDao.updateAnnotation(annotation, annotationID, principalDao.getInternalIDFromURI(annotation.getOwnerRef()));
     669        Number annotationID = annotationDao.getInternalID(UUID.fromString(annotation.getId()));
     670        int updatedAnnotations = annotationDao.updateAnnotation(annotation, annotationID, principalDao.getInternalIDFromHref(annotation.getOwnerHref()));
    674671        int deletedTargets = annotationDao.deleteAllAnnotationTarget(annotationID);
    675672        int deletedPrinsipalsAccesss = annotationDao.deleteAnnotationPermissions(annotationID);
     
    688685
    689686    @Override
    690     public int updateAnnotationHeadline(Number internalID, String newHeader) {
     687    public int updateAnnotationHeadline(Number internalID, String newHeader){
    691688        return annotationDao.updateAnnotationHeadline(internalID, newHeader);
    692689    }
     
    704701    @Override
    705702    public int updateCachedMetada(CachedRepresentationInfo cachedInfo) throws NotInDataBaseException {
    706         Number internalID = cachedRepresentationDao.getInternalIDFromURI(cachedInfo.getURI());
     703        Number internalID = cachedRepresentationDao.getInternalID(UUID.fromString(cachedInfo.getId()));
    707704        return cachedRepresentationDao.updateCachedRepresentationMetadata(internalID, cachedInfo);
    708705    }
     
    716713    @Override
    717714    public boolean updateNotebookMetadata(Number notebookID, NotebookInfo upToDateNotebookInfo) throws NotInDataBaseException {
    718         Number ownerID = principalDao.getInternalIDFromURI(upToDateNotebookInfo.getOwnerRef());
     715        Number ownerID = principalDao.getInternalIDFromHref(upToDateNotebookInfo.getOwnerHref());
    719716        return notebookDao.updateNotebookMetadata(notebookID, upToDateNotebookInfo.getTitle(), ownerID);
    720717    }
     
    741738    }
    742739
     740   
    743741    @Override
    744742    public Map<String, String> addTargetsForAnnotation(Number annotationID, List<TargetInfo> targets) throws NotInDataBaseException {
     
    746744        for (TargetInfo targetInfo : targets) {
    747745            try {
    748                 Number targetIDRunner = targetDao.getInternalIDFromURI(targetInfo.getRef());
     746                Number targetIDRunner = targetDao.getInternalIDFromHref(targetInfo.getHref());
    749747                int affectedRows = annotationDao.addAnnotationTarget(annotationID, targetIDRunner);
    750748            } catch (NotInDataBaseException e) {
    751749                Target newTarget = this.createFreshTarget(targetInfo);
    752750                Number targetID = targetDao.addTarget(newTarget);
    753                 String targetTemporaryID = targetDao.stringURItoExternalID(targetInfo.getRef());
    754                 result.put(targetTemporaryID, targetDao.getExternalID(targetID).toString());
     751                String targetTemporaryId = targetInfo.getHref();
     752                result.put(targetTemporaryId, targetDao.getHrefFromInternalID(targetID));
    755753                int affectedRows = annotationDao.addAnnotationTarget(annotationID, targetID);
    756754            }
     
    784782        List<Permission> permissions = notebook.getPermissions().getPermission();
    785783        for (Permission permission : permissions) {
    786             Number principalID = principalDao.getInternalIDFromURI(permission.getPrincipalRef());
     784            Number principalID = principalDao.getInternalIDFromHref(permission.getPrincipalHref());
    787785            Access access = permission.getLevel();
    788786            boolean updateAccesss = notebookDao.addAccessToNotebook(notebookID, principalID, access);
     
    947945    }
    948946
    949     //// priveee ///
     947    //// privee ///
    950948    private Target createFreshTarget(TargetInfo targetInfo) {
    951949        Target target = new Target();
     
    982980            int addedPermissions = 0;
    983981            for (Permission permission : permissions) {
    984                 addedPermissions = addedPermissions + annotationDao.addAnnotationPrincipalAccess(annotationID, principalDao.getInternalIDFromURI(permission.getPrincipalRef()), permission.getLevel());
     982                addedPermissions = addedPermissions + annotationDao.addAnnotationPrincipalAccess(annotationID, principalDao.getInternalIDFromHref(permission.getPrincipalHref()), permission.getLevel());
    985983            }
    986984            return addedPermissions;
     
    992990    private TargetInfo getTargetInfoFromTarget(Target target) {
    993991        TargetInfo targetInfo = new TargetInfo();
    994         targetInfo.setRef(target.getURI());
     992        targetInfo.setHref(target.getHref());
    995993        targetInfo.setLink(target.getLink());
    996994        targetInfo.setVersion(target.getVersion());
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcAnnotationDao.java

    r5186 r5385  
    6161
    6262    @Override
    63     public void setServiceURI(String serviceURI) {
    64         _serviceURI = serviceURI;
     63    public void setResourcePath(String relResourcePath) {
     64        _relResourcePath = relResourcePath;
    6565    }
    6666
     
    218218        public AnnotationInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
    219219            AnnotationInfo annotationInfo = new AnnotationInfo();
    220             annotationInfo.setRef(externalIDtoURI(rs.getString(external_id)));
     220            String externalId = rs.getString(external_id);
     221            annotationInfo.setHref(externalIDtoHref(externalId));
    221222            annotationInfo.setHeadline(rs.getString(headline));
    222223            annotationInfo.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
     
    249250        @Override
    250251        public String mapRow(ResultSet rs, int rowNumber) throws SQLException {
    251             return externalIDtoURI(rs.getString(external_id));
     252            return externalIDtoHref(rs.getString(external_id));
    252253        }
    253254    };
     
    300301
    301302            annotation.setTargets(null);
    302             annotation.setURI(externalIDtoURI(rs.getString(external_id)));
     303            String externalId = rs.getString(external_id);
     304            annotation.setId(externalId);           
     305            annotation.setHref(externalIDtoHref(externalId));
    303306            annotation.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
    304307            return annotation;
     
    398401
    399402        String[] body = retrieveBodyComponents(annotation.getBody());
    400        
    401         String externalID = this.stringURItoExternalID(annotation.getURI());
     403               
    402404        Map<String, Object> params = new HashMap<String, Object>();
    403405        params.put("owner", newOwnerID);
     
    406408        params.put("headline", annotation.getHeadline());
    407409        params.put("isXml", annotation.getBody().getXmlBody() != null);
    408         params.put("externalId", externalID);
     410        params.put("externalId", annotation.getId());
    409411        params.put("annotationId", annotationID);
    410412
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcCachedRepresentationDao.java

    r4941 r5385  
    5151
    5252    @Override
    53     public void setServiceURI(String serviceURI) {
    54         _serviceURI = serviceURI;
     53    public void setResourcePath(String relResourcePath) {
     54        _relResourcePath = relResourcePath;
    5555    }
    5656
     
    6868            CachedRepresentationInfo result = new CachedRepresentationInfo();
    6969            result.setMimeType(rs.getString(mime_type));
    70             result.setURI(externalIDtoURI(rs.getString(external_id)));
     70            String externalId = rs.getString(external_id);
     71            result.setId(externalId);
     72            result.setHref(externalIDtoHref(externalId));
    7173            result.setTool(rs.getString(tool));
    7274            result.setType(rs.getString(type_));
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcNotebookDao.java

    r4903 r5385  
    107107        public NotebookInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
    108108            NotebookInfo notebookInfo = new NotebookInfo();
    109             notebookInfo.setRef(externalIDtoURI(rs.getString(external_id)));
     109            String externalId = rs.getString(external_id);
     110            notebookInfo.setHref(externalIDtoHref(externalId));
    110111            notebookInfo.setTitle(rs.getString(title));
    111112            return notebookInfo;
     
    128129            notebook.setTitle(rs.getString(title));
    129130            notebook.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
    130             notebook.setURI(externalIDtoURI(rs.getString(external_id)));
     131            String externalId = rs.getString(external_id);
     132            notebook.setId(externalId);
     133            notebook.setHref(externalIDtoHref(externalId));
    131134            return notebook;
    132135        }
     
    247250                append(" ) VALUES (:externalId, :owner, :title)");
    248251        int affectedRows = this.loggedUpdate(sql.toString(), params);
    249         return getInternalID(externalID);
     252        return this.getInternalID(externalID);
    250253    }
    251254
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcPrincipalDao.java

    r5186 r5385  
    5050
    5151    @Override
    52     public void setServiceURI(String serviceURI) {
    53         _serviceURI = serviceURI;
     52    public void setResourcePath(String relResourcePath) {
     53        _relResourcePath = relResourcePath;
    5454    }
    5555
     
    6666        public Principal mapRow(ResultSet rs, int rowNumber) throws SQLException {
    6767            Principal result = new Principal();
    68             result.setURI(externalIDtoURI(rs.getString(external_id)));
     68            String externalId = rs.getString(external_id);
     69            result.setId(externalId);
     70            result.setHref(externalIDtoHref(externalId));
    6971            result.setDisplayName(rs.getString(principal_name));
    7072            result.setEMail(rs.getString(e_mail));
     
    142144    }
    143145
     146    @Override
     147    public UUID getPrincipalExternalIDFromRemoteID(String remoteID) throws NotInDataBaseException {
     148
     149        StringBuilder requestDB = new StringBuilder("SELECT ");
     150        requestDB.append(external_id).append(" FROM ").append(principalTableName).append(" WHERE ").append(remote_id).append("= ? LIMIT 1");
     151        List<UUID> result = this.loggedQuery(requestDB.toString(), externalIDRowMapper, remoteID);
     152        if (result.isEmpty()) {
     153            throw new NotInDataBaseException("principal", "remote ID", remoteID);
     154        }
     155        return result.get(0);
     156    }
     157   
    144158    @Override
    145159    public String getTypeOfPrincipalAccount(Number internalID) {
     
    244258    @Override
    245259    public Number updatePrincipal(Principal principal) throws NotInDataBaseException {
    246         Number principalID = this.getInternalIDFromURI(principal.getURI());
     260        Number principalID = this.getInternalID(UUID.fromString(principal.getId()));
    247261        StringBuilder sql = new StringBuilder("UPDATE ");
    248262        sql.append(principalTableName).append(" SET ").
     
    262276
    263277        if (principalIsInUse(internalID)) {
    264             throw new PrincipalCannotBeDeleted(this.getURIFromInternalID(internalID));
     278            throw new PrincipalCannotBeDeleted(this.getHrefFromInternalID(internalID));
    265279        }
    266280        StringBuilder sql = new StringBuilder("DELETE FROM ");
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcResourceDao.java

    r5174 r5385  
    2828import java.util.List;
    2929import java.util.Map;
    30 import java.util.Set;
    3130import java.util.UUID;
    3231import javax.xml.datatype.DatatypeConfigurationException;
     
    103102    protected String internalIdName = null;
    104103    protected String resourceTableName = null;
    105     protected String _serviceURI;
     104    protected String _relResourcePath;
    106105    private final Logger _logger = LoggerFactory.getLogger(JdbcResourceDao.class);
    107106    protected String nullArgument = "Null argument is given to the method.";
     
    149148    /////////////////// Class field SETTERS /////////////
    150149    @Override
    151     public void setServiceURI(String serviceURI) {
    152         _serviceURI = serviceURI;
     150    public void setResourcePath(String relResourcePath) {
     151        _relResourcePath = relResourcePath;
    153152    }
    154153
     
    176175    }
    177176
     177   
     178
    178179    //////////////////////////////////////////////
    179180    @Override
    180     public Number getInternalIDFromURI(String uri) throws NotInDataBaseException {
    181         String externalID = this.stringURItoExternalID(uri);
    182         try {
    183             UUID externalUUID = UUID.fromString(externalID);
    184             return this.getInternalID(externalUUID);
    185         } catch (IllegalArgumentException e) {
    186             _logger.info(externalID + " is not a valid <uuid>.  Therefore, I expect that it is a temporary idendifier of a new resource that is not yet.");
    187             throw new NotInDataBaseException(resourceTableName, "external  ID", externalID);
    188         }
    189     }
    190 
    191     //////////////////////////////////////////////
    192     @Override
    193     public String getURIFromInternalID(Number internalID) {
    194         return externalIDtoURI(getExternalID(internalID).toString());
     181    public String getHrefFromInternalID(Number internalID) {
     182        return this.externalIDtoHref(getExternalID(internalID).toString());
     183    }
     184   
     185     //////////////////////////////////////////////
     186    @Override
     187    public Number getInternalIDFromHref(String href) throws NotInDataBaseException{
     188        try{
     189        return this.getInternalID(UUID.fromString(this.hrefToExternalID(href)));
     190        } catch (IllegalArgumentException e){
     191           throw new NotInDataBaseException("resource", "identifier", href); 
     192        }
    195193    }
    196194
     
    257255
    258256    ////// END ROW MAPPERS /////
    259     @Override
    260     public String externalIDtoURI(String externalID) {
    261         if (_serviceURI != null) {
    262             return _serviceURI + externalID;
     257   
     258    protected String externalIDtoHref(String externalID) {
     259        if (_relResourcePath != null) {
     260            return _relResourcePath + externalID;
    263261        } else {
    264262            return externalID;
     
    266264    }
    267265
    268     @Override
    269     public String stringURItoExternalID(String stringURI) {       
    270         if (stringURI.length() > _serviceURI.length()) {
    271             return stringURI.substring(_serviceURI.length());
     266   
     267    protected String hrefToExternalID(String stringURI) {       
     268        if (stringURI.length() > _relResourcePath.length()) {
     269            return stringURI.substring(_relResourcePath.length());
    272270        } else {
    273             logger.debug(stringURI + " does not have the form <service url>/<isentifier>, therefore I return the input value.");
     271            logger.debug(stringURI + " does not have the form <rel url>/<isentifier>, therefore I return the input value.");
    274272            return stringURI;
    275273        }
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcTargetDao.java

    r5203 r5385  
    5050
    5151    @Override
    52     public void setServiceURI(String serviceURI) {
    53         _serviceURI = serviceURI;
     52    public void setResourcePath(String relResourcePath) {
     53        _relResourcePath = relResourcePath;
    5454    }
    5555
     
    240240    private TargetInfo constructTargetInfo(String externalID, String link, String version, String fragment) {
    241241        TargetInfo targetInfo = new TargetInfo();
    242         targetInfo.setRef(externalIDtoURI(externalID));
     242        targetInfo.setHref(externalIDtoHref(externalID));
    243243        targetInfo.setLink(((new StringBuilder(link)).append("#").append(fragment)).toString());
    244244        targetInfo.setVersion(version);
     
    248248    private Target constructTarget(String externalID, String link, String version, XMLGregorianCalendar xmlTimeStamp, String fragment) {
    249249        Target target = new Target();
    250         target.setURI(externalIDtoURI(externalID));
     250        target.setId(externalID);
     251        target.setHref(externalIDtoHref(externalID));
    251252        target.setLastModified(xmlTimeStamp);
    252253        if (fragment != null) {
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/AnnotationResource.java

    r5174 r5385  
    4848import javax.ws.rs.QueryParam;
    4949import javax.ws.rs.core.MediaType;
    50 import javax.ws.rs.core.UriInfo;
    5150import javax.ws.rs.ext.Providers;
    5251import javax.xml.bind.JAXBElement;
     
    6261@Transactional(rollbackFor = {Exception.class})
    6362public class AnnotationResource extends ResourceResource {
    64 
    65     public void setUriInfo(UriInfo uriInfo) {
    66         this.uriInfo = uriInfo;
    67     }
    68 
     63   
    6964    public void setHttpServletResponse(HttpServletResponse httpServletResponse) {
    7065        this.httpServletResponse = httpServletResponse;
     
    8883    public JAXBElement<Annotation> getAnnotation(@PathParam("annotationid") String externalIdentifier) throws IOException {
    8984        Map params = new HashMap();
    90         Annotation result = (Annotation) (new RequestWrappers(this)).wrapRequestResource(params, new GetAnnotation(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier, false);
     85        Annotation result = (Annotation) (new RequestWrappers(this)).wrapRequestResource(params, new GetAnnotation(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier);
    9186        if (result != null) {
    9287            return (new ObjectFactory()).createAnnotation(result);
     
    111106    public JAXBElement<ReferenceList> getAnnotationTargets(@PathParam("annotationid") String externalIdentifier) throws IOException {
    112107        Map params = new HashMap();
    113         ReferenceList result = (ReferenceList) (new RequestWrappers(this)).wrapRequestResource(params, new GetTargetList(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier, false);
     108        ReferenceList result = (ReferenceList) (new RequestWrappers(this)).wrapRequestResource(params, new GetTargetList(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier);
    114109        if (result != null) {
    115110            return (new ObjectFactory()).createTargetList(result);
     
    171166    public JAXBElement<PermissionList> getAnnotationPermissions(@PathParam("annotationid") String externalIdentifier) throws IOException {
    172167        Map params = new HashMap();
    173         PermissionList result = (PermissionList) (new RequestWrappers(this)).wrapRequestResource(params, new GetPermissionList(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier, false);
     168        PermissionList result = (PermissionList) (new RequestWrappers(this)).wrapRequestResource(params, new GetPermissionList(), Resource.ANNOTATION, ResourceAction.READ, externalIdentifier);
    174169        if (result != null) {
    175170            return (new ObjectFactory()).createPermissionList(result);
     
    192187    public String deleteAnnotation(@PathParam("annotationid") String externalIdentifier) throws IOException {
    193188        Map params = new HashMap();
    194         int[] result = (int[]) (new RequestWrappers(this)).wrapRequestResource(params, new DeleteAnnotation(), Resource.ANNOTATION, ResourceAction.DELETE, externalIdentifier, false);
     189        int[] result = (int[]) (new RequestWrappers(this)).wrapRequestResource(params, new DeleteAnnotation(), Resource.ANNOTATION, ResourceAction.DELETE, externalIdentifier);
    195190        if (result != null) {
    196191            return result[0] + " annotation(s) is(are) deleted.";
     
    246241    public JAXBElement<ResponseBody> updateAnnotation(@PathParam("annotationid") String externalId, Annotation annotation) throws IOException {
    247242
    248         String annotationURI = annotation.getURI();
    249         String path = uriInfo.getBaseUri().toString();
    250         if (!(path + "annotations/" + externalId).equals(annotationURI)) {
    251             loggerServer.debug("Wrong request: the annotation (notebook) identifier   " + externalId + " and the annotation (notebook) ID from the request body do not match.");
     243        String annotationExtId = annotation.getId();
     244        if (!(externalId).equals(annotationExtId)) {
     245            loggerServer.debug("Wrong request: the annotation identifier   " + externalId + " and the annotation (notebook) ID from the request body do not match.");
    252246            httpServletResponse.sendError(HttpServletResponse.SC_BAD_REQUEST);
    253247            return null;
     
    255249        Map params = new HashMap();
    256250        params.put("annotation", annotation);
    257         ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotation(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, externalId, false);
     251        ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotation(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, externalId);
    258252        if (result != null) {
    259253            return (new ObjectFactory()).createResponseBody(result);
     
    285279        Map params = new HashMap();
    286280        params.put("annotationBody", annotationBody);
    287         ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotationBody(), Resource.ANNOTATION, ResourceAction.WRITE, externalIdentifier, false);
     281        ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotationBody(), Resource.ANNOTATION, ResourceAction.WRITE, externalIdentifier);
    288282        if (result != null) {
    289283            return (new ObjectFactory()).createResponseBody(result);
     
    313307        Map params = new HashMap();
    314308        params.put("headline", newHeadline);
    315         ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotationHeadline(), Resource.ANNOTATION, ResourceAction.WRITE, externalIdentifier, false);
     309        ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateAnnotationHeadline(), Resource.ANNOTATION, ResourceAction.WRITE, externalIdentifier);
    316310        if (result != null) {
    317311            return (new ObjectFactory()).createResponseBody(result);
     
    341335    public String updateAccess(@PathParam("annotationid") String annotationExternalId,
    342336            @PathParam("principalid") String principalExternalId, Access access) throws IOException {
    343         return genericUpdateDeleteAccess(annotationExternalId, principalExternalId, access);
     337        return this.genericUpdateDeleteAccess(annotationExternalId, principalExternalId, access);
    344338    }
    345339    ////////////////////////////////////////////
     
    351345            final Number inputPrincipalID = dbDispatcher.getResourceInternalIdentifier(UUID.fromString(principalId), Resource.PRINCIPAL);
    352346            params.put("inputPrincipalID", inputPrincipalID);
    353             Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdatePrincipalAccess(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, annotationId, false);
     347            Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdatePrincipalAccess(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, annotationId);
    354348            if (result != null) {
    355349                return result + " row(s) is(are) updated.";
     
    386380        params.put("permissions", permissions);
    387381
    388         ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdatePermissions(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, annotationExternalId, false);
     382        ResponseBody result = (ResponseBody) (new RequestWrappers(this)).wrapRequestResource(params, new UpdatePermissions(), Resource.ANNOTATION, ResourceAction.WRITE_W_METAINFO, annotationExternalId);
    389383        if (result != null) {
    390384            return new ObjectFactory().createResponseBody(result);
     
    414408    public String deletePrincipalsAccess(@PathParam("annotationId") String annotationId,
    415409            @PathParam("principalId") String principalId) throws IOException {
    416         return genericUpdateDeleteAccess(annotationId, principalId, null);
     410        return this.genericUpdateDeleteAccess(annotationId, principalId, null);
    417411    }
    418412}
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/AutheticationResource.java

    r5275 r5385  
    1919
    2020import eu.dasish.annotation.backend.Helpers;
    21 import eu.dasish.annotation.backend.NotInDataBaseException;
    2221import eu.dasish.annotation.schema.ObjectFactory;
    2322import eu.dasish.annotation.schema.Principal;
     
    2726import javax.ws.rs.Path;
    2827import javax.ws.rs.Produces;
     28import javax.ws.rs.core.Context;
    2929import javax.ws.rs.core.MediaType;
     30import javax.ws.rs.core.UriInfo;
    3031import javax.xml.bind.JAXBElement;
    3132import javax.xml.parsers.ParserConfigurationException;
     
    4142@Transactional(rollbackFor = {Exception.class, IOException.class, ParserConfigurationException.class})
    4243public class AutheticationResource extends ResourceResource {
    43 
     44   
     45   
    4446    @GET
    4547    @Produces(MediaType.TEXT_XML)
     
    6668            Number principalID = this.getPrincipalID();
    6769            String remoteID = dbDispatcher.getPrincipalRemoteID(principalID);
    68             return Helpers.welcomeString(uriInfo.getBaseUri().toString() + "..", remoteID);
     70            return Helpers.welcomeString(httpServletRequest.getContextPath(), remoteID);
    6971        } catch (IOException e) {
    7072            return e.getMessage();
     
    8082        boolean isShibboleth = Boolean.parseBoolean(context.getInitParameter("eu.dasish.annotation.backend.isShibbolethSession"));
    8183        String redirect = isShibboleth ? context.getInitParameter("eu.dasish.annotation.backend.logout") :
    82                 uriInfo.getBaseUri().toString() + ".."+context.getInitParameter("eu.dasish.annotation.backend.logout");       
     84                httpServletRequest.getContextPath() + context.getInitParameter("eu.dasish.annotation.backend.logout");       
    8385        httpServletResponse.sendRedirect(redirect);
    8486    }
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/CachedRepresentationResource.java

    r5186 r5385  
    6666    public JAXBElement<CachedRepresentationInfo> getCachedRepresentationInfo(@PathParam("cachedid") String externalId) throws IOException {
    6767        Map params = new HashMap();
    68         CachedRepresentationInfo result = (CachedRepresentationInfo) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInfo(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId, false);
     68        CachedRepresentationInfo result = (CachedRepresentationInfo) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInfo(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId);
    6969        if (result != null) {
    7070            return (new ObjectFactory()).createCashedRepresentationInfo(result);
     
    9090    public BufferedImage getCachedRepresentationContent(@PathParam("cachedid") String externalId) throws IOException {
    9191        Map params = new HashMap();
    92         InputStream result = (InputStream) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInputStream(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId, false);
     92        InputStream result = (InputStream) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInputStream(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId);
    9393        if (result != null) {
    9494            ImageIO.setUseCache(false);
     
    114114    public InputStream getCachedRepresentationContentStream(@PathParam("cachedid") String externalId) throws IOException {
    115115        Map params = new HashMap();
    116         return (InputStream) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInputStream(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId, false);
     116        return (InputStream) (new RequestWrappers(this)).wrapRequestResource(params, new GetCachedRepresentationInputStream(), Resource.CACHED_REPRESENTATION, ResourceAction.READ, externalId);
    117117    }
    118118
     
    136136        BodyPartEntity bpe = (BodyPartEntity) multiPart.getBodyParts().get(0).getEntity();
    137137        params.put("stream", bpe.getInputStream());
    138         Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateCachedBlob(), Resource.CACHED_REPRESENTATION, ResourceAction.WRITE, cachedIdentifier, false);
     138        Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateCachedBlob(), Resource.CACHED_REPRESENTATION, ResourceAction.WRITE, cachedIdentifier);
    139139        if (result != null) {
    140140            return result + "rows are updated";
     
    168168        Map params = new HashMap();
    169169        params.put("info", cachedInfo);
    170         Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateCachedMetadata(), Resource.CACHED_REPRESENTATION, ResourceAction.WRITE_W_METAINFO, cachedInfo.getURI(), true);
     170        Integer result = (Integer) (new RequestWrappers(this)).wrapRequestResource(params, new UpdateCachedMetadata(), Resource.CACHED_REPRESENTATION, ResourceAction.WRITE_W_METAINFO, cachedInfo.getId());
    171171        if (result != null) {
    172172            return result + "rows are updated";
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/NotebookResource.java

    r5088 r5385  
    6565    @Transactional(readOnly = true)
    6666    public JAXBElement<NotebookInfoList> getNotebookInfos(@QueryParam("access") String accessMode) throws IOException {
    67         dbDispatcher.setServiceURI(uriInfo.getBaseUri().toString());
     67        dbDispatcher.setResourcesPaths(this.getRelativeServiceURI());
    6868        Number remotePrincipalID = this.getPrincipalID();
    6969        if (accessMode.equalsIgnoreCase("read") || accessMode.equalsIgnoreCase("write")) {
     
    188188            return new ObjectFactory().createResponseBody(new ResponseBody());
    189189        }
    190         String path = uriInfo.getBaseUri().toString();
    191         String notebookURI = notebookInfo.getRef();
    192         if (!(path + "notebook/" + externalIdentifier).equals(notebookURI)) {
     190        String path = this.getRelativeServiceURI();
     191        String notebookURI = notebookInfo.getHref();
     192        if (!(path + "/notebooks/" + externalIdentifier).equals(notebookURI)) {
    193193            httpServletResponse.sendError(HttpServletResponse.SC_BAD_REQUEST);
    194194            return new ObjectFactory().createResponseBody(new ResponseBody());
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/PrincipalResource.java

    r5266 r5385  
    130130        Map params = new HashMap<String, String>();
    131131        params.put("externalId", externalIdentifier);
    132         params.put("resource", this);
    133132        CurrentPrincipalInfo result = (CurrentPrincipalInfo) (new RequestWrappers(this)).wrapRequestResource(params, new GetCurrentPrincipalInfo());
    134133        return (result != null) ? (new ObjectFactory().createCurrentPrincipalInfo(result)) : (new ObjectFactory().createCurrentPrincipalInfo(new CurrentPrincipalInfo()));
     
    139138        @Override
    140139        public CurrentPrincipalInfo apply(Map params) throws NotInDataBaseException {
    141             final Number principalID = dbDispatcher.getResourceInternalIdentifier(UUID.fromString((String) params.get("externalId")), Resource.PRINCIPAL);
     140            String externalId = (String) params.get("externalId");
     141            String loggedInExternalId = (dbDispatcher.getPrincipalExternalIDFromRemoteID(httpServletRequest.getRemoteUser())).toString();
    142142            final CurrentPrincipalInfo principalInfo = new CurrentPrincipalInfo();
    143             principalInfo.setRef(dbDispatcher.getResourceURI(principalID, Resource.PRINCIPAL));
    144             principalInfo.setCurrentPrincipal(((PrincipalResource) params.get("resource")).ifLoggedIn(principalID));
     143            principalInfo.setHref(getRelativeServiceURI() + "/principals/" + externalId);
     144            principalInfo.setCurrentPrincipal(externalId.equals(loggedInExternalId));
    145145            return principalInfo;
    146146        }
     
    148148    //////////////////////////////
    149149
    150     @POST
    151     @Produces(MediaType.TEXT_PLAIN)
    152     @Path("create/{remoteId}/{password}")
    153     public String createSpringAuthenticationRecord(@PathParam("remoteId") String remoteId, @PathParam("password") String password) throws IOException {
    154         Number remotePrincipalID = this.getPrincipalID();
    155         if (remotePrincipalID == null) {
    156             return "Logged in principal is null or anonymous.";
    157         }
    158 
    159         if (dbDispatcher.getTypeOfPrincipalAccount(remotePrincipalID).equals(admin)) {
    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             }
    168         } else {
    169             this.ADMIN_RIGHTS_EXPECTED();
    170             httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
    171             return "Nothing is added.";
    172         }
    173 
    174     }
    175 
     150//    @POST
     151//    @Produces(MediaType.TEXT_PLAIN)
     152//    @Path("create/{remoteId}/{password}")
     153//    public String createSpringAuthenticationRecord(@PathParam("remoteId") String remoteId, @PathParam("password") String password) throws IOException {
     154//        Number remotePrincipalID = this.getPrincipalID();
     155//        if (remotePrincipalID == null) {
     156//            return "Logged in principal is null or anonymous.";
     157//        }
     158//
     159//        if (dbDispatcher.getTypeOfPrincipalAccount(remotePrincipalID).equals(admin)) {
     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//            }
     168//        } else {
     169//            this.ADMIN_RIGHTS_EXPECTED();
     170//            httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
     171//            return "Nothing is added.";
     172//        }
     173//
     174//    }
    176175    ///////////////////////////////////////
    177     @POST
    178     @Consumes(MediaType.APPLICATION_XML)
    179     @Produces(MediaType.APPLICATION_XML)
    180     @Path("{remoteId}")
    181     public JAXBElement<Principal> addPrincipal(@PathParam("remoteId") String remoteId, Principal principal) throws IOException {
    182 
    183         Number remotePrincipalID = this.getPrincipalID();
    184         if (remotePrincipalID == null) {
    185             return new ObjectFactory().createPrincipal(new Principal());
    186         }
    187 
    188         Map params = new HashMap<String, Object>();
    189         params.put("remoteId", remoteId);
    190         params.put("newPrincipal", principal);
    191 
    192         if (dbDispatcher.getTypeOfPrincipalAccount(remotePrincipalID).equals(admin)) {
    193             return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new AddPrincipal());
    194         } else {
    195             this.ADMIN_RIGHTS_EXPECTED();
    196             httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
    197             return new ObjectFactory().createPrincipal(new Principal());
    198         }
    199 
    200     }
    201 
    202     private class AddPrincipal implements ILambdaPrincipal<Map, Principal> {
    203 
    204         @Override
    205         public Principal apply(Map params) throws NotInDataBaseException, PrincipalExists {
    206             final Number principalID = dbDispatcher.addPrincipal((Principal) params.get("newPrincipal"), (String) params.get("remoteId"));
    207             return dbDispatcher.getPrincipal(principalID);
    208         }
    209     }
    210 
     176//    @POST
     177//    @Consumes(MediaType.APPLICATION_XML)
     178//    @Produces(MediaType.APPLICATION_XML)
     179//    @Path("{remoteId}")
     180//    public JAXBElement<Principal> addPrincipal(@PathParam("remoteId") String remoteId, Principal principal) throws IOException {
     181//
     182//        Number remotePrincipalID = this.getPrincipalID();
     183//        if (remotePrincipalID == null) {
     184//            return new ObjectFactory().createPrincipal(new Principal());
     185//        }
     186//
     187//        Map params = new HashMap<String, Object>();
     188//        params.put("remoteId", remoteId);
     189//        params.put("newPrincipal", principal);
     190//
     191//        if (dbDispatcher.getTypeOfPrincipalAccount(remotePrincipalID).equals(admin)) {
     192//            return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new AddPrincipal());
     193//        } else {
     194//            this.ADMIN_RIGHTS_EXPECTED();
     195//            httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
     196//            return new ObjectFactory().createPrincipal(new Principal());
     197//        }
     198//
     199//    }
    211200    /////////////////////////////////////
    212201    @POST
     
    227216        params.put("newPrincipal", newPrincipal);
    228217
    229         dbDispatcher.setServiceURI(uriInfo.getBaseUri().toString());
     218        dbDispatcher.setResourcesPaths(this.getRelativeServiceURI());
    230219        return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new RegisterNonShibbolizedPrincipal());
    231220    }
     
    253242            @FormParam("remoteId") String remoteId, @FormParam("email") String email)
    254243            throws IOException {
    255         dbDispatcher.setServiceURI(uriInfo.getBaseUri().toString());
     244        dbDispatcher.setResourcesPaths(this.getRelativeServiceURI());
    256245        Principal newPrincipal = new Principal();
    257246        newPrincipal.setDisplayName(name);
     
    261250        params.put("newPrincipal", newPrincipal);
    262251
    263         dbDispatcher.setServiceURI(uriInfo.getBaseUri().toString());
    264         return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new AddPrincipal());
     252        dbDispatcher.setResourcesPaths(this.getRelativeServiceURI());
     253        return (new RequestWrappers(this)).wrapAddPrincipalRequest(params, new RegisterShibbolizedPrincipal());
     254    }
     255
     256    private class RegisterShibbolizedPrincipal implements ILambdaPrincipal<Map, Principal> {
     257
     258        @Override
     259        public Principal apply(Map params) throws NotInDataBaseException, PrincipalExists {
     260            final Number principalID = dbDispatcher.addPrincipal((Principal) params.get("newPrincipal"), (String) params.get("remoteId"));
     261            return dbDispatcher.getPrincipal(principalID);
     262        }
    265263    }
    266264
     
    303301        }
    304302    }
    305     ///////////////////////////////////
    306 
     303    /////////////////////////////////
     304
     305    // logged in user can update his/her account
     306    // or account can be updated by the admin in a separate request, see above
    307307    @POST
    308308    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
     
    310310    @Path("updateme")
    311311    public JAXBElement<Principal> updatePrincipalFromForm(@FormParam("name") String name, @FormParam("email") String email)
    312             throws IOException {
    313        
     312            throws IOException, NotInDataBaseException {
     313
    314314        Principal newPrincipal = new Principal();
    315315        newPrincipal.setDisplayName(name);
    316316        newPrincipal.setEMail(email);
     317        String remoteId = httpServletRequest.getRemoteUser();
     318        String externalId = (dbDispatcher.getPrincipalExternalIDFromRemoteID(remoteId)).toString();
     319        String href = this.getRelativeServiceURI() + "/principals/" + externalId;
     320        newPrincipal.setId(externalId);
     321        newPrincipal.setHref(href);
    317322        Map params = new HashMap<String, Object>();
    318323        params.put("newPrincipal", newPrincipal);
     
    326331        public Principal apply(Map params) throws NotInDataBaseException {
    327332            Principal principal = (Principal) params.get("newPrincipal");
    328             Number principalID = (Number) params.get("principalID");
    329             String principalURI = dbDispatcher.getResourceURI(principalID, Resource.PRINCIPAL);
    330             principal.setURI(principalURI);
    331             Number principalIDupd = dbDispatcher.updatePrincipal(principal);           
     333            Number principalIDupd = dbDispatcher.updatePrincipal(principal);
    332334            return dbDispatcher.getPrincipal(principalIDupd);
    333335        }
     
    354356                }
    355357            } catch (NotInDataBaseException e) {
    356                 loggerServer.debug(e.toString());;
     358                loggerServer.debug(e.toString());
    357359                httpServletResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.toString());
    358360                return "Account is updated.";
     
    385387                }
    386388            } catch (NotInDataBaseException e) {
    387                 loggerServer.debug(e.toString());;
     389                loggerServer.debug(e.toString());
    388390                httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND, e.toString());
    389391                return "Nothing is deleted.";
     
    392394            this.ADMIN_RIGHTS_EXPECTED();
    393395            httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
    394             return "Account is not updated.";
    395         }
    396 
    397     }
    398 
    399     // silly because it is trivial. harvest all logged in users via shibboleth!!
    400     private boolean ifLoggedIn(Number principalID) {
    401         return (httpServletRequest.getRemoteUser()).equals(dbDispatcher.getPrincipalRemoteID(principalID));
     396            return "Principal is not deleted.";
     397        }
     398
    402399    }
    403400}
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/RequestWrappers.java

    r5122 r5385  
    3838public class RequestWrappers<T> {
    3939
    40    
    4140    private ResourceResource resourceResource;
    4241    private String _internalID = "internalID";
     
    6867    }
    6968
    70     public T wrapRequestResource(Map params, ILambda<Map, T> dbRequestor, Resource resource, ResourceAction action, String externalId, boolean isUri) throws IOException {
     69    public T wrapRequestResource(Map params, ILambda<Map, T> dbRequestor, Resource resource, ResourceAction action, String externalId) throws IOException {
    7170        Number principalID = resourceResource.getPrincipalID();
    7271        if (principalID == null) {
     
    7574        params.put(_principalID, principalID);
    7675        try {
    77             final Number resourceID;
    78             if (isUri) {
    79                 resourceID = resourceResource.dbDispatcher.getResourceInternalIdentifierFromURI(externalId, resource);
    80                 params.put(_externalId,  resourceResource.dbDispatcher.getResourceExternalIdentifier(resourceID, resource).toString());
    81             } else {
    82                 resourceID = resourceResource.dbDispatcher.getResourceInternalIdentifier(UUID.fromString(externalId), resource);
    83                 params.put(_externalId, externalId);
    84             }
     76            final Number resourceID = resourceResource.dbDispatcher.getResourceInternalIdentifier(UUID.fromString(externalId), resource);
    8577            if (resourceResource.dbDispatcher.canDo(action, principalID, resourceID, resource)) {
     78                params.put(_externalId, externalId);           
    8679                params.put(_internalID, resourceID);
    8780                params.put(_resourceType, resource);
     
    8982            } else {
    9083                this.FORBIDDEN_RESOURCE_ACTION(externalId, resource.name(), action.name());
    91                 resourceResource.loggerServer.debug("Principal "+resourceResource.dbDispatcher.getResourceExternalIdentifier(principalID, Resource.PRINCIPAL)+" cannot "+action.name()+" "+resource.name()+" with the id "+externalId);
     84                resourceResource.loggerServer.debug("Principal " + resourceResource.dbDispatcher.getResourceExternalIdentifier(principalID, Resource.PRINCIPAL) + " cannot " + action.name() + " " + resource.name() + " with the id " + externalId);
    9285                resourceResource.httpServletResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
    9386                return null;
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/ResourceResource.java

    r5266 r5385  
    2828import javax.servlet.http.HttpServletResponse;
    2929import javax.ws.rs.core.Context;
    30 import javax.ws.rs.core.UriInfo;
    3130import javax.ws.rs.ext.Providers;
    3231import org.slf4j.Logger;
     
    4544    protected HttpServletRequest httpServletRequest;
    4645    @Context
    47     protected HttpServletResponse httpServletResponse;
    48     @Context
    49     protected UriInfo uriInfo;
     46    protected HttpServletResponse httpServletResponse;   
    5047    @Context
    5148    protected Providers providers;
     
    5956
    6057    public Number getPrincipalID() throws IOException {
    61         dbDispatcher.setServiceURI(uriInfo.getBaseUri().toString());
     58       
     59        dbDispatcher.setResourcesPaths(this.getRelativeServiceURI());
    6260        String remotePrincipal = httpServletRequest.getRemoteUser();
    6361        if (remotePrincipal != null) {
     
    102100        loggerServer.debug(accessMode + " is an invalid access value, which must be either owner, or read, or write.");
    103101    }
     102   
     103    protected String getRelativeServiceURI(){
     104        return httpServletRequest.getContextPath()+httpServletRequest.getServletPath();
     105    }
    104106}
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/TargetResource.java

    r5088 r5385  
    7979    public JAXBElement<Target> getTarget(@PathParam("targetid") String externalIdentifier) throws IOException {
    8080        Map params = new HashMap();
    81         Target result = (Target) (new RequestWrappers(this)).wrapRequestResource(params, new GetTarget(), Resource.TARGET, ResourceAction.READ, externalIdentifier, false);
     81        Target result = (Target) (new RequestWrappers(this)).wrapRequestResource(params, new GetTarget(), Resource.TARGET, ResourceAction.READ, externalIdentifier);
    8282        if (result != null) {
    8383            return new ObjectFactory().createTarget(result);
     
    103103    public JAXBElement<ReferenceList> getSiblingTargets(@PathParam("targetid") String externalIdentifier) throws HTTPException, IOException {
    104104        Map params = new HashMap();
    105         ReferenceList result = (ReferenceList) (new RequestWrappers(this)).wrapRequestResource(params, new GetSiblingTargets(), Resource.TARGET, ResourceAction.READ, externalIdentifier, false);
     105        ReferenceList result = (ReferenceList) (new RequestWrappers(this)).wrapRequestResource(params, new GetSiblingTargets(), Resource.TARGET, ResourceAction.READ, externalIdentifier);
    106106        if (result != null) {
    107107            return new ObjectFactory().createReferenceList(result);
     
    135135        params.put("fragmentDescriptor", fragmentDescriptor);
    136136       
    137         CachedRepresentationInfo result = (CachedRepresentationInfo) (new RequestWrappers(this)).wrapRequestResource(params, new PostCached(), Resource.TARGET, ResourceAction.WRITE_W_METAINFO, targetIdentifier, false);
     137        CachedRepresentationInfo result = (CachedRepresentationInfo) (new RequestWrappers(this)).wrapRequestResource(params, new PostCached(), Resource.TARGET, ResourceAction.WRITE_W_METAINFO, targetIdentifier);
    138138        if (result != null) {
    139139            return new ObjectFactory().createCashedRepresentationInfo(result);
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/rest/WelcomeResource.java

    r5266 r5385  
    2222import javax.ws.rs.Path;
    2323import javax.ws.rs.Produces;
     24import javax.ws.rs.core.Context;
    2425import javax.ws.rs.core.MediaType;
     26import javax.ws.rs.core.UriInfo;
    2527import org.springframework.stereotype.Component;
    2628
     
    3941        String remotePrincipal= httpServletRequest.getRemoteUser();
    4042        if (remotePrincipal != null) {
    41         return Helpers.welcomeString(uriInfo.getBaseUri().toString() + "..",remotePrincipal);
     43        return Helpers.welcomeString(httpServletRequest.getContextPath(),remotePrincipal);
    4244        }
    4345        else {
    44            return Helpers.welcomeString(uriInfo.getBaseUri().toString() + "..", "null-principal");
     46           return Helpers.welcomeString(httpServletRequest.getContextPath(), "null-principal");
    4547        }
    4648    }
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/webapp/WEB-INF/web-basic.xml

    r5275 r5385  
    1919
    2020-->
     21
     22
    2123<!-- This web.xml file is not required when using Servlet 3.0 container,
    2224see implementation details http://jersey.java.net/nonav/documentation/latest/jax-rs.html#d4e194 -->
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/webapp/WEB-INF/web-shibboleth.xml

    r5275 r5385  
    1919
    2020-->
     21
    2122<!-- This web.xml file is not required when using Servlet 3.0 container,
    2223see implementation details http://jersey.java.net/nonav/documentation/latest/jax-rs.html#d4e194 -->
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/webapp/WEB-INF/web.xml

    r5275 r5385  
    2626        <param-value>/WEB-INF/shhaa.xml</param-value>
    2727    </context-param>
    28    
    29    
    3028    <context-param>
    3129        <param-name>contextConfigLocation</param-name>
     
    3432    <context-param>
    3533        <param-name>eu.dasish.annotation.backend.schemaLocation</param-name>
    36         <param-value>http://lux17.mpi.nl/schemacat/schemas/s15/files/dwan.xsd</param-value>
     34        <param-value>/Users/olhsha/repositories/DASISH/t5.6/schema/trunk/annotator-schema/src/main/resources/DASISH-schema.xsd</param-value>   
    3735    </context-param>
    3836    <context-param>
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/MockObjectsFactoryRest.java

    r5088 r5385  
    2121import javax.servlet.http.HttpServletRequest;
    2222import javax.servlet.http.HttpServletResponse;
    23 import javax.ws.rs.core.UriInfo;
    2423import javax.ws.rs.ext.Providers;
    2524import org.jmock.Mockery;
     
    3837    }
    3938
    40    
    4139    public DBDispatcher newDBDispatcher() {
    4240        return context.mock(DBDispatcher.class);
    4341    }
    44    
    45     public UriInfo newUriInfo() {
    46         return context.mock(UriInfo.class);
    47     }
    48    
    49    
    50      public Providers newProviders() {
     42
     43    public Providers newProviders() {
    5144        return context.mock(Providers.class);
    5245    }
    53    
     46
    5447    public HttpServletRequest newHttpServletRequest() {
    5548        return context.mock(HttpServletRequest.class);
    5649    }
    57    
     50
    5851    public HttpServletResponse newHttpServletResponce() {
    5952        return context.mock(HttpServletResponse.class);
    6053    }
    61    
    6254}
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/TestInstances.java

    r4903 r5385  
    2626import eu.dasish.annotation.schema.Permission;
    2727import eu.dasish.annotation.schema.PermissionList;
     28import java.util.UUID;
    2829import javax.xml.datatype.DatatypeConfigurationException;
    2930import javax.xml.datatype.DatatypeFactory;
     
    3839    final private Annotation _annotationToAdd;
    3940
    40     public TestInstances(String baseURI) {
    41         _annotationOne = makeAnnotationOne(baseURI);
    42         _annotationToAdd = makeAnnotationToAdd(baseURI);
     41    public TestInstances(String relativePath) {
     42        _annotationOne = makeAnnotationOne(relativePath);
     43        _annotationToAdd = makeAnnotationToAdd(relativePath);
    4344    }
    4445
    45     private Annotation makeAnnotationOne(String baseURI) {
    46         Annotation result = makeAnnotation(baseURI, "<html><body>some html 1</body></html>", "text/html", "Sagrada Famiglia", "00000000-0000-0000-0000-000000000111");
    47         result.setURI(baseURI+"annotations/00000000-0000-0000-0000-000000000021");
    48        
     46    private Annotation makeAnnotationOne(String relativePath) {
     47        Annotation result = makeAnnotation(relativePath, "<html><body>some html 1</body></html>", "text/html", "Sagrada Famiglia", "00000000-0000-0000-0000-000000000111", "00000000-0000-0000-0000-000000000021");
     48
    4949        try {
    5050            result.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z"));
     
    5959
    6060        Permission up1 = new Permission();
    61         up1.setPrincipalRef(baseURI + "principals/00000000-0000-0000-0000-000000000112");
     61        up1.setPrincipalHref(relativePath + "/principals/00000000-0000-0000-0000-000000000112");
    6262        up1.setLevel(Access.WRITE);
    6363
    6464        Permission up2 = new Permission();
    65         up2.setPrincipalRef(baseURI + "principals/00000000-0000-0000-0000-000000000113");
     65        up2.setPrincipalHref(relativePath + "/principals/00000000-0000-0000-0000-000000000113");
    6666        up2.setLevel(Access.READ);
    6767
     
    7272        TargetInfo target1 = new TargetInfo();
    7373        target1.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    74         target1.setRef(baseURI + "targets/00000000-0000-0000-0000-000000000031");
     74        target1.setHref(relativePath + "/targets/00000000-0000-0000-0000-000000000031");
    7575        target1.setVersion("version 1.0");
    7676
    7777        TargetInfo target2 = new TargetInfo();
    7878        target2.setLink("http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD");
    79         target2.setRef(baseURI + "targets/00000000-0000-0000-0000-000000000032");
     79        target2.setHref(relativePath + "/targets/00000000-0000-0000-0000-000000000032");
    8080        target2.setVersion("version 1.1");
    8181
     
    8686    }
    8787
    88     private Annotation makeAnnotationToAdd(String baseURI) {
    89         Annotation result = makeAnnotation(baseURI, "<html><body>some html 3</body></html>", "text/plain", "Annotation to add to test DAO", "00000000-0000-0000-0000-000000000113");
     88    private Annotation makeAnnotationToAdd(String relativePath) {
     89        Annotation result = makeAnnotation(relativePath, "<html><body>some html 3</body></html>", "text/plain", "Annotation to add to test DAO", "00000000-0000-0000-0000-000000000113",  UUID.randomUUID().toString());
    9090
    9191        TargetInfo TargetInfo = new TargetInfo();
    9292        TargetInfo.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia#de_Opdracht");
    93         TargetInfo.setRef(baseURI+  "targets/00000000-0000-0000-0000-000000000031");
     93        TargetInfo.setHref(relativePath + "/targets/00000000-0000-0000-0000-000000000031");
    9494        TargetInfo.setVersion("version 1.0");
    9595
     
    9797        targetInfos.getTargetInfo().add(TargetInfo);
    9898        result.setTargets(targetInfos);
    99        
     99
    100100        PermissionList permissions = new PermissionList();
    101101        permissions.setPublic(Access.WRITE);
    102102        result.setPermissions(permissions);
    103        
     103
    104104        return result;
    105105    }
    106106
    107     private Annotation makeAnnotation(String baseURI, String bodyTxt, String bodyMimeType, String headline, String ownerExternalId) {
     107    private Annotation makeAnnotation(String relativePath, String bodyTxt, String bodyMimeType, String headline, String ownerExternalId, String externalId) {
    108108        Annotation result = new Annotation();
     109       
    109110        AnnotationBody body = new AnnotationBody();
    110111        result.setBody(body);
     
    113114        textBody.setMimeType(bodyMimeType);
    114115        textBody.setBody(bodyTxt);
    115 
     116       
    116117        result.setHeadline(headline);
    117 
    118         if (baseURI != null) {
    119             result.setOwnerRef(baseURI + "principals/" + ownerExternalId);
    120         } else {
    121             result.setOwnerRef("principals/" + ownerExternalId);
    122         }
    123 
     118        result.setOwnerHref(relativePath + "/principals/" + ownerExternalId);
    124119        result.setLastModified(null);
    125         result.setURI(null);
     120        result.setId(externalId);
     121        result.setHref(relativePath + "/annotations/"+externalId);
    126122        result.setTargets(null);
    127         result.setURI(null);
    128 
    129123        return result;
    130124    }
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/DBDispatcherTest.java

    r5203 r5385  
    2222import eu.dasish.annotation.backend.PrincipalExists;
    2323import eu.dasish.annotation.backend.Resource;
    24 import eu.dasish.annotation.backend.TestBackendConstants;
    2524import eu.dasish.annotation.backend.TestInstances;
    2625import eu.dasish.annotation.backend.dao.AnnotationDao;
     
    9392    @Autowired
    9493    private NotebookDao notebookDao;
    95     TestInstances testInstances = new TestInstances(TestBackendConstants._TEST_SERVLET_URI);
    96 
    97     public DBDispatcherTest() {
    98     }
     94    TestInstances testInstances = new TestInstances("/api");
     95
     96    public DBDispatcherTest() {       
     97    }
     98   
     99   
    99100
    100101    ///////// GETTERS /////////////
     
    103104     * DBIntegrityServiceImlp.
    104105     */
     106   
    105107    @Test
    106108    public void testGetAnnotationInternalIdentifier() throws NotInDataBaseException {
    107109        System.out.println("getAnnotationInternalIdentifier");
     110       
    108111        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000021");
    109         //dbIntegrityService.setResourceList();
    110112        mockeryDao.checking(new Expectations() {
    111113            {
     
    125127        System.out.println("getAnnotationExternalIdentifier");
    126128        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000021");
    127 
     129       
    128130        mockeryDao.checking(new Expectations() {
    129131            {
     
    142144    public void testGetPrincipalInternalIdentifier() throws NotInDataBaseException {
    143145        System.out.println("getPrincipalInternalIdentifier");
    144 
     146       
    145147        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000111");
    146148
     
    162164        System.out.println("getPrincipalExternalIdentifier");
    163165        final UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000111");
    164 
     166       
    165167        mockeryDao.checking(new Expectations() {
    166168            {
     
    178180    public void testGetAnnotation() throws Exception {
    179181        System.out.println("test getAnnotation");
    180 
     182       
    181183        final Annotation mockAnnotation = new Annotation();// corresponds to the annotation # 1
    182         mockAnnotation.setURI(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021");
     184        mockAnnotation.setHref("/api/annotations/00000000-0000-0000-0000-000000000021");
     185        mockAnnotation.setId("00000000-0000-0000-0000-000000000021");
    183186        mockAnnotation.setHeadline("Sagrada Famiglia");
    184187        XMLGregorianCalendar mockTimeStamp = DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z");
    185188        mockAnnotation.setLastModified(mockTimeStamp);
    186         mockAnnotation.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000111");
     189        mockAnnotation.setOwnerHref("/api/principals/00000000-0000-0000-0000-000000000111");
    187190
    188191        AnnotationBody mockBody = new AnnotationBody();
     
    201204        final Target mockTargetOne = new Target();
    202205        mockTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    203         mockTargetOne.setURI(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031");
     206        mockTargetOne.setId("00000000-0000-0000-0000-000000000031");
     207        mockTargetOne.setHref("/api/targets/00000000-0000-0000-0000-000000000031");
    204208        mockTargetOne.setVersion("version 1.0");
    205209
    206210        final Target mockTargetTwo = new Target();
    207211        mockTargetTwo.setLink("http://nl.wikipedia.org/wiki/Antoni_Gaud%C3%AD");
    208         mockTargetTwo.setURI(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032");
     212        mockTargetTwo.setId("00000000-0000-0000-0000-000000000032");
     213        mockTargetTwo.setHref("/api/targets/00000000-0000-0000-0000-000000000032");
    209214        mockTargetTwo.setVersion("version 1.1");
    210215
     
    220225        listMap.add(map4);
    221226
    222         final String uri1 = TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000111";
    223         final String uri2 = TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000112";
    224         final String uri3 = TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113";
    225         final String uri4 = TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000221";
     227        final String uri1 = "/api/principals/00000000-0000-0000-0000-000000000111";
     228        final String uri2 = "/api/principals/00000000-0000-0000-0000-000000000112";
     229        final String uri3 = "/api/principals/00000000-0000-0000-0000-000000000113";
     230        final String uri4 = "/api/principals/00000000-0000-0000-0000-000000000221";
    226231
    227232
     
    234239                will(returnValue(1));
    235240
    236                 oneOf(principalDao).getURIFromInternalID(1);
     241                oneOf(principalDao).getHrefFromInternalID(1);
    237242                will(returnValue(uri1));
    238243
     
    254259                will(returnValue(Access.WRITE));
    255260
    256                 oneOf(principalDao).getURIFromInternalID(2);
     261                oneOf(principalDao).getHrefFromInternalID(2);
    257262                will(returnValue(uri2));
    258263
    259                 oneOf(principalDao).getURIFromInternalID(3);
     264                oneOf(principalDao).getHrefFromInternalID(3);
    260265                will(returnValue(uri3));
    261266
    262                 oneOf(principalDao).getURIFromInternalID(11);
     267                oneOf(principalDao).getHrefFromInternalID(11);
    263268                will(returnValue(uri4));
    264269            }
     
    266271
    267272        Annotation result = dbDispatcher.getAnnotation(1);
    268         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021", result.getURI());
     273        assertEquals("00000000-0000-0000-0000-000000000021", result.getId());
     274        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getHref());
    269275        assertEquals("text/plain", result.getBody().getTextBody().getMimeType());
    270276        assertEquals("<html><body>some html 1</body></html>", result.getBody().getTextBody().getBody());
    271277        assertEquals("Sagrada Famiglia", result.getHeadline());
    272278        assertEquals("2013-08-12T09:25:00.383000Z", result.getLastModified().toString());
    273         assertEquals(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000111", result.getOwnerRef());
     279        assertEquals("/api/principals/00000000-0000-0000-0000-000000000111", result.getOwnerHref());
    274280
    275281        assertEquals(mockTargetOne.getLink(), result.getTargets().getTargetInfo().get(0).getLink());
    276         assertEquals(mockTargetOne.getURI(), result.getTargets().getTargetInfo().get(0).getRef());
     282        assertEquals(mockTargetOne.getHref(), result.getTargets().getTargetInfo().get(0).getHref());
    277283        assertEquals(mockTargetOne.getVersion(), result.getTargets().getTargetInfo().get(0).getVersion());
    278284        assertEquals(mockTargetTwo.getLink(), result.getTargets().getTargetInfo().get(1).getLink());
    279         assertEquals(mockTargetTwo.getURI(), result.getTargets().getTargetInfo().get(1).getRef());
     285        assertEquals(mockTargetTwo.getHref(), result.getTargets().getTargetInfo().get(1).getHref());
    280286        assertEquals(mockTargetTwo.getVersion(), result.getTargets().getTargetInfo().get(1).getVersion());
    281287
     
    283289
    284290        assertEquals(Access.WRITE, result.getPermissions().getPermission().get(0).getLevel());
    285         assertEquals(uri2, result.getPermissions().getPermission().get(0).getPrincipalRef());
     291        assertEquals(uri2, result.getPermissions().getPermission().get(0).getPrincipalHref());
    286292
    287293        assertEquals(Access.READ, result.getPermissions().getPermission().get(1).getLevel());
    288         assertEquals(uri3, result.getPermissions().getPermission().get(1).getPrincipalRef());
     294        assertEquals(uri3, result.getPermissions().getPermission().get(1).getPrincipalHref());
    289295
    290296        assertEquals(Access.READ, result.getPermissions().getPermission().get(2).getLevel());
    291         assertEquals(uri4, result.getPermissions().getPermission().get(2).getPrincipalRef());
     297        assertEquals(uri4, result.getPermissions().getPermission().get(2).getPrincipalHref());
    292298
    293299        assertEquals(Access.WRITE, result.getPermissions().getPublic());
     
    300306    public void testGetFilteredAnnotationIDs() throws NotInDataBaseException {
    301307        System.out.println("test getFilteredAnnotationIDs");
    302        
     308        
    303309        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    304310        mockAnnotationIDs1.add(1);
     
    367373    public void testGetFilteredAnnotationIDs2() throws NotInDataBaseException {
    368374        System.out.println("test getFilteredAnnotationIDs");
    369 
    370        
     375       
    371376        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    372377        mockAnnotationIDs1.add(1);
     
    434439    public void testGetFilteredAnnotationIDs3() throws NotInDataBaseException {
    435440        System.out.println("test getFilteredAnnotationIDs");
    436 
    437441       
    438442        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
     
    459463    public void testGetFilteredAnnotationIDs4() throws NotInDataBaseException {
    460464        System.out.println("test getFilteredAnnotationIDs");
    461 
    462        
    463 
     465       
    464466        final String after = (new Timestamp(0)).toString();
    465467        final String before = (new Timestamp(System.currentTimeMillis())).toString();
     
    488490    public void testGetAnnotationTargets() throws SQLException {
    489491        System.out.println("test getAnnotationTargets");
    490         final List<Number> TargetIDs = new ArrayList<Number>();
    491         TargetIDs.add(1);
    492         TargetIDs.add(2);
     492       
     493        final List<Number> targetIDs = new ArrayList<Number>();
     494        targetIDs.add(1);
     495        targetIDs.add(2);
    493496        mockeryDao.checking(new Expectations() {
    494497            {
    495498                oneOf(targetDao).getTargetIDs(1);
    496                 will(returnValue(TargetIDs));
    497 
    498                 oneOf(targetDao).getURIFromInternalID(1);
    499                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031"));
    500 
    501                 oneOf(targetDao).getURIFromInternalID(2);
    502                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032"));
     499                will(returnValue(targetIDs));
     500
     501                oneOf(targetDao).getHrefFromInternalID(1);
     502                will(returnValue("/api/targets/00000000-0000-0000-0000-000000000031"));
     503
     504                oneOf(targetDao).getHrefFromInternalID(2);
     505                will(returnValue("/api/targets/00000000-0000-0000-0000-000000000032"));
    503506
    504507            }
     
    506509
    507510        ReferenceList result = dbDispatcher.getAnnotationTargets(1);
    508         assertEquals(2, result.getRef().size());
    509         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031", result.getRef().get(0));
    510         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032", result.getRef().get(1));
     511        assertEquals(2, result.getHref().size());
     512        assertEquals("/api/targets/00000000-0000-0000-0000-000000000031", result.getHref().get(0));
     513        assertEquals("/api/targets/00000000-0000-0000-0000-000000000032", result.getHref().get(1));
    511514
    512515    }
     
    524527    public void testGetFilteredAnnotationInfos() throws NotInDataBaseException {
    525528        System.out.println("test getetFilteredAnnotationInfos");
    526 
    527 
     529       
    528530        final List<Number> mockAnnotationIDs1 = new ArrayList<Number>();
    529531        mockAnnotationIDs1.add(1);
     
    563565
    564566        mockAnnotInfo.setHeadline("Sagrada Famiglia");
    565         mockAnnotInfo.setRef(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021");
    566         mockAnnotInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000111");
     567        mockAnnotInfo.setHref("/api/annotations/00000000-0000-0000-0000-000000000021");
     568        mockAnnotInfo.setOwnerHref("/api/principals/00000000-0000-0000-0000-000000000111");
    567569
    568570        final List<Number> targetIDs = new ArrayList<Number>();
     
    608610                will(returnValue(1));
    609611
    610                 oneOf(principalDao).getURIFromInternalID(1);
    611                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000111"));
     612                oneOf(principalDao).getHrefFromInternalID(1);
     613                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000111"));
    612614
    613615                ////
     
    615617                will(returnValue(targetIDs));
    616618
    617                 oneOf(targetDao).getURIFromInternalID(1);
    618                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031"));
    619 
    620 
    621                 oneOf(targetDao).getURIFromInternalID(2);
    622                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032"));
     619                oneOf(targetDao).getHrefFromInternalID(1);
     620                will(returnValue("/api/targets/00000000-0000-0000-0000-000000000031"));
     621
     622
     623                oneOf(targetDao).getHrefFromInternalID(2);
     624                will(returnValue("/api/targets/00000000-0000-0000-0000-000000000032"));
    623625
    624626
     
    630632        assertEquals(1, result.getAnnotationInfo().size());
    631633        AnnotationInfo resultAnnotInfo = result.getAnnotationInfo().get(0);
    632         assertEquals(mockAnnotInfo.getHeadline(), resultAnnotInfo.getHeadline());
    633         assertEquals(mockAnnotInfo.getRef(), resultAnnotInfo.getRef());
    634         assertEquals(mockAnnotInfo.getOwnerRef(), resultAnnotInfo.getOwnerRef());
    635         assertEquals(mockAnnotInfo.getRef(), result.getAnnotationInfo().get(0).getRef());
    636         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031", resultAnnotInfo.getTargets().getRef().get(0));
    637         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032", resultAnnotInfo.getTargets().getRef().get(1));
     634        assertEquals("Sagrada Famiglia", resultAnnotInfo.getHeadline());
     635        assertEquals("/api/principals/00000000-0000-0000-0000-000000000111", resultAnnotInfo.getOwnerHref());
     636        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getAnnotationInfo().get(0).getHref());
     637        assertEquals("/api/targets/00000000-0000-0000-0000-000000000031", resultAnnotInfo.getTargets().getHref().get(0));
     638        assertEquals("/api/targets/00000000-0000-0000-0000-000000000032", resultAnnotInfo.getTargets().getHref().get(1));
    638639
    639640    }
     
    642643    public void testGetTargetsWithNoCachedRepresentation() {
    643644        System.out.println("test getTargetsWithNoCachedRepresentation");
     645     
    644646        final List<Number> targetIDs = new ArrayList<Number>();
    645647        targetIDs.add(5);
     
    663665                will(returnValue(cachedIDs7));
    664666
    665                 oneOf(targetDao).getURIFromInternalID(7);
    666                 will(returnValue("00000000-0000-0000-0000-000000000037"));
     667                oneOf(targetDao).getHrefFromInternalID(7);
     668                will(returnValue("/api/targets/00000000-0000-0000-0000-000000000037"));
    667669
    668670            }
     
    671673        List<String> result = dbDispatcher.getTargetsWithNoCachedRepresentation(3);
    672674        assertEquals(1, result.size());
    673         assertEquals("00000000-0000-0000-0000-000000000037", result.get(0)); // Target number 7 has no cached
     675        assertEquals("/api/targets/00000000-0000-0000-0000-000000000037", result.get(0)); // Target number 7 has no cached
    674676    }
    675677
     
    680682    @Test
    681683    public void testAddCached() throws SerialException, IOException, NotInDataBaseException {
    682         System.out.println("addCached");
     684        System.out.println("test addCached");
     685       
    683686        String mime = "text/html";
    684687        String type = "text";
     
    689692        newCachedInfo.setType(type);
    690693        newCachedInfo.setTool(tool);
    691         newCachedInfo.setURI(TestBackendConstants._TEST_SERVLET_URI_cached + externalID);
    692 
     694        newCachedInfo.setHref("/api/cached/" + externalID);
     695        newCachedInfo.setId(externalID);
     696       
    693697        String blobString = "aaa";
    694698        byte[] blobBytes = blobString.getBytes();
     
    697701        mockeryDao.checking(new Expectations() {
    698702            {
    699 
    700                 oneOf(cachedRepresentationDao).getInternalIDFromURI(newCachedInfo.getURI());
    701                 will(returnValue(null));
    702703
    703704                oneOf(cachedRepresentationDao).addCachedRepresentation(newCachedInfo, newCachedBlob);
     
    729730    public void testAddTargetsForAnnotation() throws Exception {
    730731        System.out.println("test addTargetsForAnnotation");
    731 
     732       
    732733        // test 1: adding an existing target
    733734        TargetInfo testTargetOne = new TargetInfo();
    734735        testTargetOne.setLink("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia");
    735         testTargetOne.setRef(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031");
     736        testTargetOne.setHref("/api/targets/00000000-0000-0000-0000-000000000031");
    736737        testTargetOne.setVersion("version 1.0");
    737738        final List<TargetInfo> mockTargetListOne = new ArrayList<TargetInfo>();
     
    740741        mockeryDao.checking(new Expectations() {
    741742            {
    742                 oneOf(targetDao).getInternalIDFromURI(mockTargetListOne.get(0).getRef());
     743                oneOf(targetDao).getInternalIDFromHref(mockTargetListOne.get(0).getHref());
    743744                will(returnValue(1));
    744745
     
    753754        // test 2: adding a new Target
    754755        TargetInfo testTargetTwo = new TargetInfo();
    755         final String tempTargetID = UUID.randomUUID().toString();
    756         testTargetTwo.setRef(TestBackendConstants._TEST_SERVLET_URI_targets + tempTargetID);
     756        final String tempTargetID = "/api/targets/"+UUID.randomUUID().toString();
     757        testTargetTwo.setHref(tempTargetID);
    757758        testTargetTwo.setLink("http://www.sagradafamilia.cat/docs_instit/historia.php");
    758759        testTargetTwo.setVersion("version 1.0");
     
    763764        final NotInDataBaseException e = new NotInDataBaseException("target", "external ID", tempTargetID);
    764765
    765         mockeryDao.checking(new Expectations() {
    766             {
    767                 oneOf(targetDao).getInternalIDFromURI(mockTargetListTwo.get(0).getRef());
     766//        Target newTarget = this.createFreshTarget(targetInfo);
     767//                Number targetID = targetDao.addTarget(newTarget);
     768//                String targetTemporaryId = targetInfo.getHref();
     769//                result.put(targetTemporaryId, targetDao.getExternalID(targetID).toString());
     770//                int affectedRows = annotationDao.addAnnotationTarget(annotationID, targetID);
     771//       
     772        mockeryDao.checking(new Expectations() {
     773            {
     774                oneOf(targetDao).getInternalIDFromHref(mockTargetListTwo.get(0).getHref());
    768775                will(throwException(e));
    769776
     
    771778                will(returnValue(8)); //# the next new number is 8, we have already 7 Targets
    772779
    773                 oneOf(targetDao).stringURItoExternalID(mockTargetListTwo.get(0).getRef());
    774                 will(returnValue(tempTargetID));
    775 
    776                 oneOf(targetDao).getExternalID(8);
    777                 will(returnValue(mockNewTargetUUID));
     780                oneOf(targetDao).getHrefFromInternalID(8);
     781                will(returnValue("/api/targets/"+mockNewTargetUUID.toString()));
    778782
    779783                oneOf(annotationDao).addAnnotationTarget(1, 8);
     
    785789        Map<String, String> resultTwo = dbDispatcher.addTargetsForAnnotation(1, mockTargetListTwo);
    786790        assertEquals(1, resultTwo.size());
    787         assertEquals(mockNewTargetUUID.toString(), resultTwo.get(tempTargetID));
     791        assertEquals("/api/targets/"+mockNewTargetUUID.toString(), resultTwo.get(tempTargetID));
    788792
    789793    }
     
    805809
    806810                //  expectations for addTargetsForannotation
    807                 oneOf(targetDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031");
     811                oneOf(targetDao).getInternalIDFromHref("/api/targets/00000000-0000-0000-0000-000000000031");
    808812                will(returnValue(1));
    809813
     
    824828        assertEquals(5, result);
    825829
    826 //        Annotation newAnnotation = dbIntegrityService.getAnnotation(5);
    827 //        assertEquals(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113", newAnnotation.getOwnerRef());
     830//        Annotation newAnnotation = dbDispatcher.getAnnotation(5);
     831//        assertEquals("/api/principals/00000000-0000-0000-0000-000000000113", newAnnotation.getOwnerHref());
    828832//        assertEquals(testAnnotation.getHeadline(), newAnnotation.getHeadline());
    829833//        assertEquals(testAnnotation.getBody().getTextBody().getBody(), newAnnotation.getBody().getTextBody().getBody());
     
    10711075
    10721076        final NotebookInfo mockNotebookInfo = new NotebookInfo();
    1073         mockNotebookInfo.setRef("00000000-0000-0000-0000-000000000011");
     1077        mockNotebookInfo.setHref("/api/notebooks/00000000-0000-0000-0000-000000000011");
    10741078        mockNotebookInfo.setTitle("Notebook 1");
    10751079
     
    10851089                will(returnValue(1));
    10861090
    1087                 oneOf(principalDao).getURIFromInternalID(1);
    1088                 will(returnValue("00000000-0000-0000-0000-000000000111"));
     1091                oneOf(principalDao).getHrefFromInternalID(1);
     1092                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000111"));
    10891093
    10901094            }
     
    10921096
    10931097        NotebookInfoList result = dbDispatcher.getNotebooks(3, Access.READ);
    1094         assertEquals("00000000-0000-0000-0000-000000000011", result.getNotebookInfo().get(0).getRef());
    1095         assertEquals("00000000-0000-0000-0000-000000000111", result.getNotebookInfo().get(0).getOwnerRef());
     1098        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000011", result.getNotebookInfo().get(0).getHref());
     1099        assertEquals("/api/principals/00000000-0000-0000-0000-000000000111", result.getNotebookInfo().get(0).getOwnerHref());
    10961100        assertEquals("Notebook 1", result.getNotebookInfo().get(0).getTitle());
    10971101
     
    11071111
    11081112        final NotebookInfo mockNotebookInfo1 = new NotebookInfo();
    1109         mockNotebookInfo1.setRef("00000000-0000-0000-0000-000000000013");
     1113        mockNotebookInfo1.setHref("/api/notebooks/00000000-0000-0000-0000-000000000013");
    11101114        mockNotebookInfo1.setTitle("Notebook 3");
    11111115
    11121116        final NotebookInfo mockNotebookInfo2 = new NotebookInfo();
    1113         mockNotebookInfo2.setRef("00000000-0000-0000-0000-000000000014");
     1117        mockNotebookInfo2.setHref("/api/notebooks/00000000-0000-0000-0000-000000000014");
    11141118        mockNotebookInfo2.setTitle("Notebook 4");
    11151119
     
    11191123                will(returnValue(mockNotebookIDs));
    11201124
    1121                 oneOf(principalDao).getURIFromInternalID(3);
    1122                 will(returnValue("00000000-0000-0000-0000-000000000113"));
     1125                oneOf(principalDao).getHrefFromInternalID(3);
     1126                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000113"));
    11231127
    11241128                oneOf(notebookDao).getNotebookInfoWithoutOwner(3);
     
    11311135        });
    11321136
    1133 //       NotebookInfoList result = dbIntegrityService.getNotebooks(3, "owner");       
    1134 //       assertEquals("00000000-0000-0000-0000-000000000013", result.getNotebookInfo().get(0).getRef());//        assertEquals("00000000-0000-0000-0000-000000000113", result.getNotebookInfo().get(0).getOwnerRef());
     1137        //??
     1138//        NotebookInfoList result = dbDispatcher.getNotebooks(3, "owner");
     1139//        assertEquals("00000000-0000-0000-0000-000000000013", result.getNotebookInfo().get(0).getRef());//        assertEquals("00000000-0000-0000-0000-000000000113", result.getNotebookInfo().get(0).getOwnerRef());
    11351140//        assertEquals("Notebook 3", result.getNotebookInfo().get(0).getTitle());
    11361141//        assertEquals("00000000-0000-0000-0000-000000000014", result.getNotebookInfo().get(1).getRef());
     
    11611166                will(returnValue(mockNotebookIDs));
    11621167
    1163                 oneOf(notebookDao).getURIFromInternalID(3);
    1164                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013"));
    1165 
    1166                 oneOf(notebookDao).getURIFromInternalID(4);
    1167                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014"));
     1168                oneOf(notebookDao).getHrefFromInternalID(3);
     1169                will(returnValue("/api/notebooks/00000000-0000-0000-0000-000000000013"));
     1170
     1171                oneOf(notebookDao).getHrefFromInternalID(4);
     1172                will(returnValue("/api/notebooks/00000000-0000-0000-0000-000000000014"));
    11681173
    11691174            }
     
    11711176
    11721177        ReferenceList result = dbDispatcher.getNotebooksOwnedBy(3);
    1173         assertEquals(2, result.getRef().size());
    1174         assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013", result.getRef().get(0));
    1175         assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014", result.getRef().get(1));
     1178        assertEquals(2, result.getHref().size());
     1179        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000013", result.getHref().get(0));
     1180        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000014", result.getHref().get(1));
    11761181    }
    11771182
     
    12291234                will(returnValue(mockPrincipalIDs));
    12301235
    1231                 oneOf(principalDao).getURIFromInternalID(2);
    1232                 will(returnValue("serviceURI/principals/00000000-0000-0000-0000-000000000112"));
    1233 
    1234                 oneOf(principalDao).getURIFromInternalID(4);
    1235                 will(returnValue("serviceURI/principals/00000000-0000-0000-0000-000000000114"));
     1236                oneOf(principalDao).getHrefFromInternalID(2);
     1237                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000112"));
     1238
     1239                oneOf(principalDao).getHrefFromInternalID(4);
     1240                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000114"));
    12361241
    12371242
     
    12401245
    12411246        ReferenceList result = dbDispatcher.getPrincipals(1, "write");
    1242         assertEquals("serviceURI/principals/00000000-0000-0000-0000-000000000112", result.getRef().get(0).toString());
    1243         assertEquals("serviceURI/principals/00000000-0000-0000-0000-000000000114", result.getRef().get(1).toString());
     1247        assertEquals("/api/principals/00000000-0000-0000-0000-000000000112", result.getHref().get(0).toString());
     1248        assertEquals("/api/principals/00000000-0000-0000-0000-000000000114", result.getHref().get(1).toString());
    12441249
    12451250    }
     
    12811286
    12821287        final Notebook mockNotebook = new Notebook();
    1283         mockNotebook.setURI("serviceURI/notebooks/00000000-0000-0000-0000-000000000012");
     1288        mockNotebook.setHref("/api/notebooks/00000000-0000-0000-0000-000000000012");
     1289        mockNotebook.setId("00000000-0000-0000-0000-000000000012");
    12841290        mockNotebook.setTitle("Notebook 2");
    12851291        mockNotebook.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar("2014-02-12T09:25:00.383000Z"));
     
    13021308                will(returnValue(2));
    13031309
    1304                 oneOf(principalDao).getURIFromInternalID(2);
    1305                 will(returnValue("serviceURI/principals/00000000-0000-0000-0000-000000000112"));
     1310                oneOf(principalDao).getHrefFromInternalID(2);
     1311                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000112"));
    13061312
    13071313                oneOf(annotationDao).getAnnotations(2);
    13081314                will(returnValue(mockAnnotations));
    13091315
    1310                 oneOf(annotationDao).getURIFromInternalID(3);
    1311                 will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000023"));
     1316                oneOf(annotationDao).getHrefFromInternalID(3);
     1317                will(returnValue("/api/annotations/00000000-0000-0000-0000-000000000023"));
    13121318
    13131319                oneOf(principalDao).getPrincipalIDsWithAccessForNotebook(2, Access.READ);
    13141320                will(returnValue(mockREADs));
    13151321
    1316                 oneOf(principalDao).getURIFromInternalID(1);
    1317                 will(returnValue("serviceURI/principals/00000000-0000-0000-0000-000000000111"));
     1322                oneOf(principalDao).getHrefFromInternalID(1);
     1323                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000111"));
    13181324
    13191325                oneOf(principalDao).getPrincipalIDsWithAccessForNotebook(2, Access.WRITE);
    13201326                will(returnValue(mockWRITEs));
    13211327
    1322                 oneOf(principalDao).getURIFromInternalID(3);
    1323                 will(returnValue("serviceURI/principals/00000000-0000-0000-0000-000000000113"));
     1328                oneOf(principalDao).getHrefFromInternalID(3);
     1329                will(returnValue("/api/principals/00000000-0000-0000-0000-000000000113"));
    13241330
    13251331
     
    13291335
    13301336        Notebook result = dbDispatcher.getNotebook(2);
    1331         assertEquals("serviceURI/notebooks/00000000-0000-0000-0000-000000000012", result.getURI());
    1332         assertEquals("serviceURI/principals/00000000-0000-0000-0000-000000000112", result.getOwnerRef());
     1337        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000012", result.getHref());
     1338        assertEquals("00000000-0000-0000-0000-000000000012", result.getId());
     1339        assertEquals("/api/principals/00000000-0000-0000-0000-000000000112", result.getOwnerRef());
    13331340        assertEquals("2014-02-12T09:25:00.383000Z", result.getLastModified().toString());
    13341341        assertEquals("Notebook 2", result.getTitle());
    1335         assertEquals(1, result.getAnnotations().getRef().size());
    1336         assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000023", result.getAnnotations().getRef().get(0));
     1342        assertEquals(1, result.getAnnotations().getHref().size());
     1343        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000023", result.getAnnotations().getHref().get(0));
    13371344        assertEquals(2, result.getPermissions().getPermission().size());
    1338         assertEquals("serviceURI/principals/00000000-0000-0000-0000-000000000111", result.getPermissions().getPermission().get(0).getPrincipalRef());
     1345        assertEquals("/api/principals/00000000-0000-0000-0000-000000000111", result.getPermissions().getPermission().get(0).getPrincipalHref());
    13391346        assertEquals("read", result.getPermissions().getPermission().get(0).getLevel().value());
    1340         assertEquals("serviceURI/principals/00000000-0000-0000-0000-000000000113", result.getPermissions().getPermission().get(1).getPrincipalRef());
     1347        assertEquals("/api/principals/00000000-0000-0000-0000-000000000113", result.getPermissions().getPermission().get(1).getPrincipalHref());
    13411348        assertEquals("write", result.getPermissions().getPermission().get(1).getLevel().value());
    13421349
     
    13571364                will(returnValue(mockAnnotationIDs));
    13581365
    1359                 oneOf(annotationDao).getURIFromInternalID(1);
    1360                 will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000021"));
    1361 
    1362                 oneOf(annotationDao).getURIFromInternalID(2);
    1363                 will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000022"));
     1366                oneOf(annotationDao).getHrefFromInternalID(1);
     1367                will(returnValue("/api/annotations/00000000-0000-0000-0000-000000000021"));
     1368
     1369                oneOf(annotationDao).getHrefFromInternalID(2);
     1370                will(returnValue("/api/annotations/00000000-0000-0000-0000-000000000022"));
    13641371
    13651372
     
    13691376
    13701377        ReferenceList result = dbDispatcher.getAnnotationsForNotebook(1, -1, 3, "last_modified", true);
    1371         assertEquals(2, result.getRef().size());
    1372         assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000021", result.getRef().get(0).toString());
    1373         assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000022", result.getRef().get(1).toString());
     1378        assertEquals(2, result.getHref().size());
     1379        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getHref().get(0).toString());
     1380        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000022", result.getHref().get(1).toString());
    13741381
    13751382    }
     
    13861393
    13871394        final NotebookInfo mockNotebookInfo = new NotebookInfo();
    1388         mockNotebookInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113");
     1395        mockNotebookInfo.setOwnerHref("/api/principals/00000000-0000-0000-0000-000000000113");
    13891396        mockNotebookInfo.setTitle("New Title");
    13901397
    13911398        mockeryDao.checking(new Expectations() {
    13921399            {
    1393                 oneOf(principalDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113");
     1400                oneOf(principalDao).getInternalIDFromHref("/api/principals/00000000-0000-0000-0000-000000000113");
    13941401                will(returnValue(3));
    13951402
     
    14411448        notebook.setOwnerRef("tmpXXX");
    14421449        notebook.setTitle("(Almost) Copy of Notebook 1");
    1443         notebook.setURI("tmpYYY");
     1450        notebook.setId("tmpYYY");
     1451        notebook.setHref("whatever");
    14441452
    14451453        PermissionList accesss = new PermissionList();
    14461454        Permission p1 = new Permission();
    14471455        p1.setLevel(Access.WRITE);
    1448         p1.setPrincipalRef(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000112");
     1456        p1.setPrincipalHref("/api/principals/00000000-0000-0000-0000-000000000112");
    14491457        accesss.getPermission().add(p1);
    14501458        Permission p2 = new Permission();
    14511459        p2.setLevel(Access.READ);
    1452         p2.setPrincipalRef(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113");
     1460        p2.setPrincipalHref("/api/principals/00000000-0000-0000-0000-000000000113");
    14531461        accesss.getPermission().add(p2);
    14541462        notebook.setPermissions(accesss);
     
    14621470                will(returnValue(true));
    14631471
    1464                 oneOf(principalDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000112");
     1472                oneOf(principalDao).getInternalIDFromHref("/api/principals/00000000-0000-0000-0000-000000000112");
    14651473                will(returnValue(2));
    14661474
    1467                 oneOf(principalDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_principals + "00000000-0000-0000-0000-000000000113");
     1475                oneOf(principalDao).getInternalIDFromHref("/api/principals/00000000-0000-0000-0000-000000000113");
    14681476                will(returnValue(3));
    14691477
     
    14971505
    14981506                //  expectations for addTargetsForannotation
    1499                 oneOf(targetDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031");
     1507                oneOf(targetDao).getInternalIDFromHref("/api/targets/00000000-0000-0000-0000-000000000031");
    15001508                will(returnValue(1));
    15011509
     
    16421650        System.out.println("test updateAnnotation");
    16431651
    1644         final Annotation annotation = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationOne();
     1652        final Annotation annotation = (new TestInstances("/api")).getAnnotationOne();
    16451653        final NotInDataBaseException e = new NotInDataBaseException("annotation", "external ID", "00000000-0000-0000-0000-000000000031");
    16461654        final String mockTempID = "00000000-0000-0000-0000-000000000031";
     
    16521660        mockeryDao.checking(new Expectations() {
    16531661            {
    1654                 oneOf(annotationDao).getInternalIDFromURI(annotation.getURI());
    1655                 will(returnValue(1));
    1656 
    1657                 oneOf(principalDao).getInternalIDFromURI(annotation.getOwnerRef());
     1662                oneOf(annotationDao).getInternalID(UUID.fromString(annotation.getId()));
     1663                will(returnValue(1));
     1664
     1665                oneOf(principalDao).getInternalIDFromHref(annotation.getOwnerHref());
    16581666                will(returnValue(1));
    16591667
     
    16701678                /// adding the first target, nt foind in the DB
    16711679
    1672                 oneOf(targetDao).getInternalIDFromURI(annotation.getTargets().getTargetInfo().get(0).getRef());
     1680                oneOf(targetDao).getInternalIDFromHref(annotation.getTargets().getTargetInfo().get(0).getHref());
    16731681                will(throwException(e));
    16741682
     
    16761684                will(returnValue(8));
    16771685
    1678                 oneOf(targetDao).stringURItoExternalID(annotation.getTargets().getTargetInfo().get(0).getRef());
    1679                 will(returnValue(mockTempID));
    1680 
    1681                 oneOf(targetDao).getExternalID(8);
    1682                 will(returnValue(mockNewID));
     1686                oneOf(targetDao).getHrefFromInternalID(8);
     1687                will(returnValue("/api/targets/"+mockNewID.toString()));
    16831688
    16841689                oneOf(annotationDao).addAnnotationTarget(1, 8);
     
    16861691
    16871692                /////////
    1688                 oneOf(targetDao).getInternalIDFromURI(annotation.getTargets().getTargetInfo().get(1).getRef());
     1693                oneOf(targetDao).getInternalIDFromHref(annotation.getTargets().getTargetInfo().get(1).getHref());
    16891694                will(returnValue(2));
    16901695
     
    16931698
    16941699                /////
    1695                 oneOf(principalDao).getInternalIDFromURI(permissions.getPermission().get(0).getPrincipalRef());
     1700                oneOf(principalDao).getInternalIDFromHref(permissions.getPermission().get(0).getPrincipalHref());
    16961701                will(returnValue(2));
    16971702
     
    16991704                will(returnValue(1));
    17001705
    1701                 oneOf(principalDao).getInternalIDFromURI(permissions.getPermission().get(1).getPrincipalRef());
     1706                oneOf(principalDao).getInternalIDFromHref(permissions.getPermission().get(1).getPrincipalHref());
    17021707                will(returnValue(3));
    17031708
     
    17251730    public void testUpdateHeadline() throws NotInDataBaseException {
    17261731
    1727         System.out.println("test updateAnnotation");
    1728 
    1729         final Annotation annotation = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationOne();
    1730        
    1731 
    1732         System.out.println("test updateAnnotation");
    1733         mockeryDao.checking(new Expectations() {
    1734             {
    1735                 oneOf(annotationDao).getInternalIDFromURI(annotation.getURI());
    1736                 will(returnValue(1));
    1737 
    1738                 oneOf(principalDao).getInternalIDFromURI(annotation.getOwnerRef());
    1739                 will(returnValue(1));
    1740 
    1741                 oneOf(annotationDao).updateAnnotationHeadline(1, "new Headline");
     1732        System.out.println("test updateAnnotationHeadline  ");
     1733        mockeryDao.checking(new Expectations() {
     1734            { oneOf(annotationDao).updateAnnotationHeadline(1, "new Headline");
    17421735                will(returnValue(1));
    17431736
     
    17941787       
    17951788        Permission permission2 = new Permission();
    1796         permission2.setPrincipalRef("ref2");
     1789        permission2.setPrincipalHref("/api/principals/ref2");
    17971790        permission2.setLevel(Access.WRITE);
    17981791
    17991792        Permission permission3 = new Permission();
    1800         permission3.setPrincipalRef("ref3");
     1793        permission3.setPrincipalHref("/api/principals/ref3");
    18011794        permission3.setLevel(Access.READ);
    18021795             
    18031796        Permission permission4 = new Permission();
    18041797        permission4.setLevel(Access.READ);
    1805         permission4.setPrincipalRef("ref4");
     1798        permission4.setPrincipalHref("/api/principals/ref4");
    18061799       
    18071800        permissions.getPermission().add(permission2);
     
    18161809                will(returnValue(1));
    18171810
    1818                 oneOf(principalDao).getInternalIDFromURI(permissions.getPermission().get(0).getPrincipalRef());
     1811                oneOf(principalDao).getInternalIDFromHref(permissions.getPermission().get(0).getPrincipalHref());
    18191812                will(returnValue(2));
    18201813
     
    18221815                will(returnValue(Access.WRITE));
    18231816
    1824                 oneOf(principalDao).getInternalIDFromURI(permissions.getPermission().get(1).getPrincipalRef());
     1817                oneOf(principalDao).getInternalIDFromHref(permissions.getPermission().get(1).getPrincipalHref());
    18251818                will(returnValue(3));
    18261819
     
    18281821                will(returnValue(Access.WRITE));
    18291822               
    1830                 oneOf(principalDao).getInternalIDFromURI(permissions.getPermission().get(2).getPrincipalRef());
     1823                oneOf(principalDao).getInternalIDFromHref(permissions.getPermission().get(2).getPrincipalHref());
    18311824                will(returnValue(4));
    18321825
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcAnnotationDaoTest.java

    r5186 r5385  
    2020import eu.dasish.annotation.backend.Helpers;
    2121import eu.dasish.annotation.backend.NotInDataBaseException;
    22 import eu.dasish.annotation.backend.TestBackendConstants;
    2322import eu.dasish.annotation.backend.TestInstances;
    2423import eu.dasish.annotation.schema.Annotation;
     
    5756    @Autowired
    5857    JdbcAnnotationDao jdbcAnnotationDao;
    59     TestInstances testInstances = new TestInstances(TestBackendConstants._TEST_SERVLET_URI);
     58    TestInstances testInstances = new TestInstances("/api");
    6059
    6160    /**
     
    6463     */
    6564    @Test
    66     public void testStringURItoExternalID() {
     65    public void testHrefToExternalID() {
    6766        System.out.println("test stringURItoExternalID");
    68         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     67        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    6968        String randomUUID = UUID.randomUUID().toString();
    70         String uri = TestBackendConstants._TEST_SERVLET_URI_annotations + randomUUID;
    71         String externalID = jdbcAnnotationDao.stringURItoExternalID(uri);
    72         assertEquals(randomUUID, externalID);
     69        String uri = "/api/annotations/" + randomUUID;
     70        String uuid = jdbcAnnotationDao.hrefToExternalID(uri);
     71        assertEquals(randomUUID, uuid);
    7372    }
    7473
     
    7877     */
    7978    @Test
    80     public void testExternalIDtoURI() {
    81         System.out.println("test stringURItoExternalID");
    82         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     79    public void testExternalIDtoHref() {
     80        System.out.println("test externalIDtoHref");
     81        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    8382        String randomUUID = UUID.randomUUID().toString();
    84         String uri = TestBackendConstants._TEST_SERVLET_URI_annotations + randomUUID;
    85         String uriResult = jdbcAnnotationDao.externalIDtoURI(randomUUID);
     83        String uri = "/api/annotations/" + randomUUID;
     84        String uriResult = jdbcAnnotationDao.externalIDtoHref(randomUUID);
    8685        assertEquals(uri, uriResult);
    8786    }
     
    147146        annotIds.add(3);
    148147
    149         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     148        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    150149        final List<String> testList = jdbcAnnotationDao.getAnnotationREFs(annotIds);
    151150        assertEquals(3, testList.size());
    152         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021", testList.get(0));
    153         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000022", testList.get(1));
    154         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000023", testList.get(2));
     151        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", testList.get(0));
     152        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000022", testList.get(1));
     153        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000023", testList.get(2));
    155154
    156155        final List<String> testListTwo = jdbcAnnotationDao.getAnnotationREFs(new ArrayList<Number>());
     
    185184     */
    186185    @Test
    187     public void testGetInternalIDFRomURI() throws NotInDataBaseException {
    188         System.out.println("test getInternalIDFromURI");
    189         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
    190         String uri = TestBackendConstants._TEST_SERVLET_URI_annotations + "00000000-0000-0000-0000-000000000021";
    191         Number result = jdbcAnnotationDao.getInternalIDFromURI(uri);
     186    public void testGetInternalIDFRomHref() throws NotInDataBaseException {
     187        System.out.println("test getInternalIDFromHref");
     188        jdbcAnnotationDao.setResourcePath("/api/annotations/");
     189        String uri = "/api/annotations/00000000-0000-0000-0000-000000000021";
     190        Number result = jdbcAnnotationDao.getInternalIDFromHref(uri);
    192191        assertEquals(1, result.intValue());
     192        assertEquals(1, result);
    193193    }
    194194
     
    201201    public void getAnnotationWithoutTargetsAndPermisions() throws DatatypeConfigurationException {
    202202        System.out.println("test getAnnotationWithoutTargetsAndPermissions");
    203         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     203        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    204204        final Annotation result = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(1);
    205205
     
    207207        assertEquals("<html><body>some html 1</body></html>", result.getBody().getTextBody().getBody());
    208208        assertEquals("text/html", result.getBody().getTextBody().getMimeType());
    209         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations
    210                 + "00000000-0000-0000-0000-000000000021", result.getURI());
     209        assertEquals("00000000-0000-0000-0000-000000000021", result.getId());
     210        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getHref());
    211211        assertEquals(DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z"), result.getLastModified());
    212212    }
     
    238238    public void testAddAnnotation() throws SQLException, Exception {
    239239        System.out.println("test_addAnnotation ");
    240 
     240        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    241241        final Annotation annotationToAdd = testInstances.getAnnotationToAdd();// existing Targets
    242         assertEquals(null, annotationToAdd.getURI());
    243         assertEquals(null, annotationToAdd.getLastModified());
    244 
     242       
    245243        Number newAnnotationID = jdbcAnnotationDao.addAnnotation(annotationToAdd, 3);
    246244        assertEquals(5, newAnnotationID);
     
    248246        // checking
    249247        Annotation addedAnnotation = jdbcAnnotationDao.getAnnotationWithoutTargetsAndPemissions(5);
    250         assertFalse(null == addedAnnotation.getURI());
     248        assertEquals(addedAnnotation.getHref(), "/api/annotations/"+addedAnnotation.getId());
    251249        assertFalse(null == addedAnnotation.getLastModified());
    252250        assertEquals(annotationToAdd.getBody().getTextBody().getMimeType(), addedAnnotation.getBody().getTextBody().getMimeType());
     
    393391    public void testGetAnnotationInfoWithoutTargetsAndOwner() throws DatatypeConfigurationException {
    394392        System.out.println("test getAnnotationInfoWithoutTargets");
    395         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     393        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    396394        final AnnotationInfo result = jdbcAnnotationDao.getAnnotationInfoWithoutTargetsAndOwner(1);
    397395
    398396        assertEquals("Sagrada Famiglia", result.getHeadline());
    399         assertEquals(TestBackendConstants._TEST_SERVLET_URI_annotations
    400                 + "00000000-0000-0000-0000-000000000021", result.getRef());
     397        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", result.getHref());
    401398        assertEquals(DatatypeFactory.newInstance().newXMLGregorianCalendar("2013-08-12T09:25:00.383000Z"), result.getLastModified());
    402399    }
     
    496493    public void testUpdateAnnotation() {
    497494        System.out.println("test UpdateAnnotation");
    498         jdbcAnnotationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_annotations);
     495        jdbcAnnotationDao.setResourcePath("/api/annotations/");
    499496       
    500497        Annotation annotation = testInstances.getAnnotationOne();
     
    503500        annotation.getBody().getTextBody().setMimeType("text/plain");
    504501
    505         System.out.println(annotation.getURI());
     502       
    506503        int result = jdbcAnnotationDao.updateAnnotation(annotation,1, 1);
    507504        assertEquals(1, result);
     
    511508        assertEquals("text/plain", check.getBody().getTextBody().getMimeType());
    512509        assertEquals("updated headline 1", check.getHeadline());
    513 
     510        assertEquals("/api/annotations/00000000-0000-0000-0000-000000000021", check.getHref());
     511        assertEquals("00000000-0000-0000-0000-000000000021", check.getId());
    514512    }
    515513   
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcCachedRepresentationDaoTest.java

    r4941 r5385  
    1919
    2020import eu.dasish.annotation.backend.NotInDataBaseException;
    21 import eu.dasish.annotation.backend.TestBackendConstants;
    2221import eu.dasish.annotation.schema.CachedRepresentationInfo;
    2322import java.io.ByteArrayInputStream;
     
    4948     */
    5049    @Test
    51     public void testStringURItoExternalID() {
    52         System.out.println("test stringURItoExternalID");
    53         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
     50    public void testHrefToExternalID() {
     51        System.out.println("test hrefToExternalID");
     52        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
    5453        String randomUUID = UUID.randomUUID().toString();
    55         String uri = TestBackendConstants._TEST_SERVLET_URI_cached + randomUUID;
    56         String externalID = jdbcCachedRepresentationDao.stringURItoExternalID(uri);
    57         assertEquals(randomUUID, externalID);
     54        String uri = "/api/cached/" + randomUUID;
     55        String check = jdbcCachedRepresentationDao.hrefToExternalID(uri);
     56        assertEquals(randomUUID, check);
    5857    }
    5958   
     
    6362     */
    6463    @Test
    65     public void testExternalIDtoURI() {
     64    public void testExternalIdToHref() {
    6665        System.out.println("test stringURItoExternalID");
    67         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
     66        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
    6867        String randomUUID = UUID.randomUUID().toString();
    69         String uri = TestBackendConstants._TEST_SERVLET_URI_cached+randomUUID;
    70         String uriResult = jdbcCachedRepresentationDao.externalIDtoURI(randomUUID);
     68        String uri = "/api/cached/"+randomUUID;
     69        String uriResult = jdbcCachedRepresentationDao.externalIDtoHref(randomUUID);
    7170        assertEquals(uri, uriResult);
    7271    }
     
    8483    public void testGetExternalId() {
    8584        System.out.println("getExternalId");
    86         Number internalID = 1;
    8785        UUID expResult = UUID.fromString("00000000-0000-0000-0000-000000000051");
    88         UUID result = jdbcCachedRepresentationDao.getExternalID(internalID);
     86        UUID result = jdbcCachedRepresentationDao.getExternalID(1);
    8987        assertEquals(expResult, result);
    9088    }
     
    110108    public void testGetInternalIDFRomURI() throws NotInDataBaseException{
    111109        System.out.println("test getInternalIDFromURI");
    112         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
    113         String uri = TestBackendConstants._TEST_SERVLET_URI_cached +"00000000-0000-0000-0000-000000000051";
    114         Number result = jdbcCachedRepresentationDao.getInternalIDFromURI(uri);
     110        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
     111        String uri = "/api/cached/00000000-0000-0000-0000-000000000051";
     112        Number result = jdbcCachedRepresentationDao.getInternalIDFromHref(uri);
    115113        assertEquals(1, result.intValue());
    116114    }
     
    125123        System.out.println("getCachedRepresentationInfo");
    126124
    127         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
     125        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
    128126        CachedRepresentationInfo result = jdbcCachedRepresentationDao.getCachedRepresentationInfo(1);
    129         assertEquals(TestBackendConstants._TEST_SERVLET_URI_cached + "00000000-0000-0000-0000-000000000051", result.getURI());
     127        assertEquals("/api/cached/00000000-0000-0000-0000-000000000051", result.getHref());
     128        assertEquals("00000000-0000-0000-0000-000000000051", result.getId());
    130129        assertEquals("image/png", result.getMimeType());
    131130        assertEquals("screen-shot", result.getTool());
     
    140139    public void testGetCachedRepresentations() {
    141140        System.out.println("test getCachedRepresentationsForTarget");
    142         Number TargetID = 1;
    143         List<Number> result = jdbcCachedRepresentationDao.getCachedRepresentationsForTarget(TargetID);
     141        List<Number> result = jdbcCachedRepresentationDao.getCachedRepresentationsForTarget(1);
    144142        assertEquals(1, result.get(0));
    145143        assertEquals(2, result.get(1));
     
    154152    public void testDeleteCachedRepresentation() {
    155153        System.out.println("deleteCachedRepresentationInfo");
    156         Number internalID = 6; /// deleted because no version refers to it
    157         int result = jdbcCachedRepresentationDao.deleteCachedRepresentation(internalID);
     154        /// deleted because no version refers to it
     155        int result = jdbcCachedRepresentationDao.deleteCachedRepresentation(6);
    158156        assertEquals(1, result);
    159157
     
    163161    public void testUpdateCachedRepresentationMetadata(){
    164162        System.out.println("test updateCachedRepresentationInfo");
    165         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
     163        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
    166164        CachedRepresentationInfo cachedInfo = new CachedRepresentationInfo();
    167165        cachedInfo.setMimeType("update mime type  1");
    168166        cachedInfo.setType("update type  1");
    169167        cachedInfo.setTool("update tool  1");
    170         cachedInfo.setURI(TestBackendConstants._TEST_SERVLET_URI_cached + "00000000-0000-0000-0000-00000000005c");
    171168       
    172169        int result = jdbcCachedRepresentationDao.updateCachedRepresentationMetadata(1, cachedInfo);
     
    174171       
    175172        CachedRepresentationInfo newCached = jdbcCachedRepresentationDao.getCachedRepresentationInfo(1);
    176         assertEquals(TestBackendConstants._TEST_SERVLET_URI_cached + "00000000-0000-0000-0000-000000000051", newCached.getURI());
     173        assertEquals("/api/cached/00000000-0000-0000-0000-000000000051", newCached.getHref());
     174        assertEquals("00000000-0000-0000-0000-000000000051", newCached.getId());
    177175        assertEquals("update mime type  1", newCached.getMimeType());
    178176        assertEquals("update tool  1", newCached.getTool());
     
    184182    public void testUpdateCachedRepresentationBlob() throws IOException{
    185183        System.out.println("test updateCachedRepresentationBlob");
    186         jdbcCachedRepresentationDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
     184        jdbcCachedRepresentationDao.setResourcePath("/api/cached/");
    187185        String blobString = " test blobbie ";
    188186        byte[] blobBytes = blobString.getBytes();
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcNotebookDaoTest.java

    r4834 r5385  
    8585    public void testGetNotebookInfoWithoutOwner() {
    8686        System.out.println("test getNotebookInfoWithoutOwner");
     87        jdbcNotebookDao.setResourcePath("/api/notebooks/");
    8788        NotebookInfo result = jdbcNotebookDao.getNotebookInfoWithoutOwner(1);
    88         assertEquals("00000000-0000-0000-0000-000000000011", result.getRef());
     89        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000011", result.getHref());
    8990        assertEquals("Notebook 1", result.getTitle());
    90         assertEquals(null, result.getOwnerRef());
     91        assertEquals(null, result.getOwnerHref());
    9192    }
    9293
     
    9899    public void testGetNotebookWithoutAnnotationsAndAccesssAndOwner() {
    99100        System.out.println("test getNotebookWithoutAnnotationsAndAccesssAndOwner");
     101        jdbcNotebookDao.setResourcePath("/api/notebooks/");
    100102        Notebook result = jdbcNotebookDao.getNotebookWithoutAnnotationsAndAccesssAndOwner(1);
    101         assertEquals("00000000-0000-0000-0000-000000000011", result.getURI());
     103        assertEquals("/api/notebooks/00000000-0000-0000-0000-000000000011", result.getHref());
     104        assertEquals("00000000-0000-0000-0000-000000000011", result.getId());
    102105        assertEquals("Notebook 1", result.getTitle());
    103106        assertEquals("2013-08-12T09:25:00.383000Z", result.getLastModified().toString());
     
    149152    public void testCreateNotebookWithoutAccesssAndAnnotations() throws NotInDataBaseException, DatatypeConfigurationException {
    150153        System.out.println("test createNotebookWithoutAccesssAndAnnotations");
     154        jdbcNotebookDao.setResourcePath("/api/notebooks/");
    151155        Notebook notebook = new Notebook();
    152156        notebook.setTitle("New test notebook");
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcPrincipalDaoTest.java

    r4995 r5385  
    1818package eu.dasish.annotation.backend.dao.impl;
    1919
    20 import eu.dasish.annotation.backend.Helpers;
     20
    2121import eu.dasish.annotation.backend.NotInDataBaseException;
    2222import eu.dasish.annotation.backend.PrincipalCannotBeDeleted;
    23 import eu.dasish.annotation.backend.TestBackendConstants;
    2423import eu.dasish.annotation.backend.TestInstances;
    2524import eu.dasish.annotation.schema.Access;
     
    4544    @Autowired
    4645    JdbcPrincipalDao jdbcPrincipalDao;
    47     TestInstances testInstances = new TestInstances(TestBackendConstants._TEST_SERVLET_URI);
    4846   
    4947     /**
     
    5250     */
    5351    @Test
    54     public void testStringURItoExternalID() {
    55         System.out.println("test stringURItoExternalID");
    56         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
     52    public void testHrefToExternalID() {
     53        System.out.println("test hrefToExternalID");
     54        jdbcPrincipalDao.setResourcePath("/api/principals/");
    5755        String randomUUID = UUID.randomUUID().toString();
    58         String uri = TestBackendConstants._TEST_SERVLET_URI_principals + randomUUID;
    59         String externalID = jdbcPrincipalDao.stringURItoExternalID(uri);
     56        String uri = "/api/principals/" + randomUUID;
     57        String externalID = jdbcPrincipalDao.hrefToExternalID(uri).toString();
    6058        assertEquals(randomUUID, externalID);
    6159    }
     
    6866    public void testExternalIDtoURI() {
    6967        System.out.println("test stringURItoExternalID");
    70         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
     68        jdbcPrincipalDao.setResourcePath("/api/principals/");
    7169        String randomUUID = UUID.randomUUID().toString();
    72         String uri = TestBackendConstants._TEST_SERVLET_URI_principals+randomUUID;
    73         String uriResult = jdbcPrincipalDao.externalIDtoURI(randomUUID);
     70        String uri = "/api/principals/"+randomUUID;
     71        String uriResult = jdbcPrincipalDao.externalIDtoHref(randomUUID);
    7472        assertEquals(uri, uriResult);
    7573    }
     
    9896    @Test
    9997    public void testGetExternalID() {
    100         UUID testOne = jdbcPrincipalDao.getExternalID(3);
    101         assertEquals("00000000-0000-0000-0000-000000000113", testOne.toString());
     98        assertEquals("00000000-0000-0000-0000-000000000113", jdbcPrincipalDao.getExternalID(3).toString());
    10299
    103100    }
     
    106103    public void testGetPrincipal() {
    107104        System.out.println("test getPrincipal");
    108         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
     105        jdbcPrincipalDao.setResourcePath("/api/principals/");
    109106        Principal result = jdbcPrincipalDao.getPrincipal(1);
    110107        assertEquals("Twan", result.getDisplayName());
    111108        assertEquals("Twan.Goosen@mpi.nl", result.getEMail());
    112         assertEquals(TestBackendConstants._TEST_SERVLET_URI_principals+"00000000-0000-0000-0000-000000000111", result.getURI());
     109        assertEquals("/api/principals/00000000-0000-0000-0000-000000000111", result.getHref());
     110        assertEquals("00000000-0000-0000-0000-000000000111", result.getId());
    113111    }
    114112
     
    116114    public void testAddPrincipal() throws NotInDataBaseException{
    117115        System.out.println("test addPrincipal");
    118         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
     116        jdbcPrincipalDao.setResourcePath("/api/principals/");
    119117        String freshPrincipalName = "Guilherme";
    120118        String freshPrincipalEmail = "guisil@mpi.nl";
     
    129127        assertEquals(freshPrincipalName, addedPrincipal.getDisplayName());
    130128        assertEquals(freshPrincipalEmail, addedPrincipal.getEMail());
    131         assertFalse(null == jdbcPrincipalDao.stringURItoExternalID(addedPrincipal.getURI()));
     129        assertEquals(addedPrincipal.getHref(), "/api/principals/"+addedPrincipal.getId());
     130       
    132131    }
    133132
     
    135134    public void testDeletePrincipal() throws PrincipalCannotBeDeleted{
    136135        System.out.println("test deletePrincipal");
    137         jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);
     136        jdbcPrincipalDao.setResourcePath("/api/principals/");
    138137
    139138        int result = jdbcPrincipalDao.deletePrincipal(10);
     
    152151    @Test
    153152    public void tesPrincipalExists() {
    154         System.out.println("test principalExists");
    155         //jdbcPrincipalDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_principals);       
     153        System.out.println("test principalExists");     
    156154        assertEquals(false,jdbcPrincipalDao.principalExists("guisil@mpi.nl"));       
    157155        assertTrue(jdbcPrincipalDao.principalExists("olhsha@mpi.nl"));
     
    170168        assertEquals(expResult, result);
    171169    }
    172    
    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        
    181     }
     170//   
     171//   @Test
     172//   public void generateHashes() {
     173//        System.out.println("*****");
     174//        System.out.println("generate hashes");
     175//        System.out.println(Helpers.hashPswd("1234", 512, "olhsha@mpi.nl"));
     176//        System.out.println(Helpers.hashPswd("5678", 512, "olasei@mpi.nl"));
     177//        System.out.println("*****");
     178//       
     179//    }
    182180
    183181}
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/dao/impl/JdbcTargetDaoTest.java

    r5138 r5385  
    1919
    2020import eu.dasish.annotation.backend.NotInDataBaseException;
    21 import eu.dasish.annotation.backend.TestBackendConstants;
    2221import eu.dasish.annotation.schema.Target;
    2322import eu.dasish.annotation.schema.TargetInfo;
     
    5049     */
    5150    @Test
    52     public void testStringURItoExternalID() {
    53         System.out.println("test stringURItoExternalID");
    54         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_targets);
     51    public void testHrefToExternalID() {
     52        System.out.println("test hrefToExternalID");
     53        jdbcTargetDao.setResourcePath("/api/targets/");
    5554        String randomUUID = UUID.randomUUID().toString();
    56         String uri = TestBackendConstants._TEST_SERVLET_URI_targets + randomUUID;
    57         String externalID = jdbcTargetDao.stringURItoExternalID(uri);
     55        String uri = "/api/targets/" + randomUUID;
     56        String externalID = (jdbcTargetDao.hrefToExternalID(uri)).toString();
    5857        assertEquals(randomUUID, externalID);
    5958    }
     
    6665    public void testExternalIDtoURI() {
    6766        System.out.println("test stringURItoExternalID");
    68         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_targets);
     67        jdbcTargetDao.setResourcePath("/api/targets/");
    6968        String randomUUID = UUID.randomUUID().toString();
    70         String uri = TestBackendConstants._TEST_SERVLET_URI_targets + randomUUID;
    71         String uriResult = jdbcTargetDao.externalIDtoURI(randomUUID);
     69        String uri = "/api/targets/" + randomUUID;
     70        String uriResult = jdbcTargetDao.externalIDtoHref(randomUUID);
    7271        assertEquals(uri, uriResult);
    7372    }
     
    7978    public void testGetExternalID() {
    8079        System.out.println("getExternalID");
    81         Number internalID = 1;
    82         UUID result = jdbcTargetDao.getExternalID(internalID);
     80        UUID result = jdbcTargetDao.getExternalID(1);
    8381        assertEquals("00000000-0000-0000-0000-000000000031", result.toString());
    8482    }
     
    9189        System.out.println("getInternalId");
    9290        UUID externalID = UUID.fromString("00000000-0000-0000-0000-000000000031");
    93         Number expResult = 1;
    9491        Number result = jdbcTargetDao.getInternalID(externalID);
    95         assertEquals(expResult, result);
     92        assertEquals(1, result);
    9693    }
    9794
     
    103100    public void testGetInternalIDFRomURI() throws NotInDataBaseException{
    104101        System.out.println("test getInternalIDFromURI");
    105         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_targets);
    106         String uri = TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031";
    107         Number result = jdbcTargetDao.getInternalIDFromURI(uri);
     102        jdbcTargetDao.setResourcePath("/api/targets/");
     103        String uri = "/api/targets/00000000-0000-0000-0000-000000000031";
     104        Number result = jdbcTargetDao.getInternalIDFromHref(uri);
    108105        assertEquals(1, result.intValue());
    109106    }
     
    115112    public void testGetTarget() {
    116113        System.out.println("getTarget");
    117         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_targets);
     114        jdbcTargetDao.setResourcePath("/api/targets/");
    118115        Target result = jdbcTargetDao.getTarget(1);
    119         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031", result.getURI());
     116        assertEquals("/api/targets/00000000-0000-0000-0000-000000000031", result.getHref());
     117        assertEquals("00000000-0000-0000-0000-000000000031", result.getId());
    120118        assertEquals("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia" + "#" + "de_Opdracht", result.getLink());
    121119        assertEquals("version 1.0", result.getVersion());
     
    167165        assertEquals("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia" + "#Het_ontwerp", addedTarget.getLink());
    168166        assertEquals("version 1.0", addedTarget.getVersion());
    169         assertTrue(addedTarget.getURI().startsWith(TestBackendConstants._TEST_SERVLET_URI_targets));
     167        assertTrue(addedTarget.getHref().startsWith("/api/targets/"));
    170168    }
    171169
     
    176174    public void testGetTargetInfos() {
    177175        System.out.println("getTargetInfos");
    178         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_targets);
     176        jdbcTargetDao.setResourcePath("/api/targets/");
    179177        List<Number> test = new ArrayList<Number>();
    180178        test.add(1);
     
    182180        List<TargetInfo> result = jdbcTargetDao.getTargetInfos(test);
    183181        assertEquals(2, result.size());
    184         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000031", result.get(0).getRef());
    185         assertEquals(TestBackendConstants._TEST_SERVLET_URI_targets + "00000000-0000-0000-0000-000000000032", result.get(1).getRef());
     182        assertEquals("/api/targets/00000000-0000-0000-0000-000000000031", result.get(0).getHref());
     183        assertEquals("/api/targets/00000000-0000-0000-0000-000000000032", result.get(1).getHref());
    186184        assertEquals("version 1.0", result.get(0).getVersion());
    187185        assertEquals("version 1.1", result.get(1).getVersion());
     
    196194    public void testRetrieveTargetIDs() {
    197195        System.out.println("retrieveTargetIDs");
    198         Number annotationID = 1;
    199         List<Number> result = jdbcTargetDao.getTargetIDs(annotationID);
     196        List<Number> result = jdbcTargetDao.getTargetIDs(1);
    200197        assertEquals(2, result.size());
    201198        assertEquals(1, result.get(0));
     
    206203    public void testUpdateTargetCachedRepresentationFragment(){
    207204        System.out.println("test updateTargetCachedRepresentationFragment");
    208         jdbcTargetDao.setServiceURI(TestBackendConstants._TEST_SERVLET_URI_cached);
    209205        int result = jdbcTargetDao.updateTargetCachedRepresentationFragment(1, 1, "updated fragment");
    210206        assertEquals(1, result);
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/rest/AnnotationResourceTest.java

    r5145 r5385  
    2222import eu.dasish.annotation.backend.ResourceAction;
    2323import eu.dasish.annotation.backend.dao.DBDispatcher;
    24 import eu.dasish.annotation.backend.TestBackendConstants;
    2524import eu.dasish.annotation.backend.TestInstances;
    2625import eu.dasish.annotation.schema.Access;
     
    4544import java.net.URI;
    4645import java.util.UUID;
    47 import javax.ws.rs.core.UriInfo;
    4846import org.springframework.mock.web.MockHttpServletRequest;
    4947
     
    5452@RunWith(value = SpringJUnit4ClassRunner.class)
    5553@ContextConfiguration(locations = {"/spring-test-config/mockeryRest.xml", "/spring-test-config/mockDBDispatcher.xml",
    56     "/spring-test-config/mockUriInfo.xml",
    5754    "/spring-config/jaxbMarshallerFactory.xml", "/spring-config/jaxbUnmarshallerFactory.xml"})
    5855public class AnnotationResourceTest {
     
    6158    private Mockery mockeryRest;
    6259    @Autowired
    63     private DBDispatcher mockDbDispatcher;
    64     @Autowired
    65     UriInfo mockUriInfo;
     60    private DBDispatcher mockDbDispatcher;   
    6661    @Autowired
    6762    private AnnotationResource annotationResource;
     
    7368
    7469//    public Number getPrincipalID() throws IOException {
    75 //        dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
     70//        dbIntegrityService.setServiceURI(this.getRelativeServiceURI());
    7671//        verboseOutput = new VerboseOutput(httpServletResponse, loggerServer);
    7772//        String remotePrincipal = httpServletRequest.getRemotePrincipal();
     
    9590        System.out.println("getAnnotation");
    9691        final String externalIDstring = "00000000-0000-0000-0000-000000000021";
    97         final Annotation expectedAnnotation = (new TestInstances(null)).getAnnotationOne();
    98         annotationResource.setHttpServletRequest(mockRequest);
    99         annotationResource.setUriInfo(mockUriInfo);
     92        final Annotation expectedAnnotation = (new TestInstances("/api")).getAnnotationOne();
     93        annotationResource.setHttpServletRequest(mockRequest);
    10094        mockRequest.setRemoteUser("olhsha@mpi.nl");
    101 
    102         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    103 
    104         mockeryRest.checking(new Expectations() {
    105             {
    106                 oneOf(mockUriInfo).getBaseUri();
    107                 will(returnValue(baseUri));
    108 
    109                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     95        mockRequest.setContextPath("/backend");
     96        mockRequest.setServletPath("/api");
     97        mockeryRest.checking(new Expectations() {
     98            {
     99               
     100                oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    110101
    111102                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("olhsha@mpi.nl");
     
    143134
    144135        annotationResource.setHttpServletRequest(mockRequest);
    145         annotationResource.setUriInfo(mockUriInfo);
    146136        mockRequest.setRemoteUser("olhsha@mpi.nl");
    147 
    148         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    149 
    150 
    151         mockeryRest.checking(new Expectations() {
    152             {
    153                 oneOf(mockUriInfo).getBaseUri();
    154                 will(returnValue(baseUri));
    155 
    156                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     137        mockRequest.setContextPath("/backend");
     138        mockRequest.setServletPath("/api");
     139       
     140        mockeryRest.checking(new Expectations() {
     141            {
     142                oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    157143
    158144                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("olhsha@mpi.nl");
     
    186172        System.out.println("test createAnnotation");
    187173
    188         final Annotation annotationToAdd = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationToAdd();
     174        final Annotation annotationToAdd = (new TestInstances("/api")).getAnnotationToAdd();
    189175        final Number newAnnotationID = 5;
    190176
    191177
    192178        final Annotation addedAnnotation = (new ObjectFactory()).createAnnotation(annotationToAdd).getValue();
    193         addedAnnotation.setURI("http://localhost:8080/annotator-backend/api/annotations/" + UUID.randomUUID().toString());
    194         addedAnnotation.setOwnerRef("http://localhost:8080/annotator-backend/api/principals/" + "00000000-0000-0000-0000-000000000113");
     179        String externalId = UUID.randomUUID().toString();
     180        addedAnnotation.setId(externalId);
     181        addedAnnotation.setHref("/backend/api/annotations/" + externalId);
     182        addedAnnotation.setOwnerHref("/backend/api/principals/00000000-0000-0000-0000-000000000113");
    195183
    196184        final ResponseBody mockEnvelope = new ResponseBody();
     
    201189        actionList.getAction().add(action);
    202190        action.setMessage(AnnotationActionName.CREATE_CACHED_REPRESENTATION.value());
    203         action.setObject("http://localhost:8080/annotator-backend/api/targets/00000000-0000-0000-0000-000000000036");
    204 
    205         annotationResource.setHttpServletRequest(mockRequest);
    206         annotationResource.setUriInfo(mockUriInfo);
     191        action.setObject("/backend/api/targets/00000000-0000-0000-0000-000000000036");
     192
     193        annotationResource.setHttpServletRequest(mockRequest);
    207194        mockRequest.setRemoteUser("olhsha@mpi.nl");
    208         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    209 
    210 //        final List<String> targets = new ArrayList<String>();
    211 //        targets.add("http://localhost:8080/annotator-backend/api/targets/00000000-0000-0000-0000-000000000036");
    212 
    213         mockeryRest.checking(new Expectations() {
    214             {
    215                 oneOf(mockUriInfo).getBaseUri();
    216                 will(returnValue(baseUri));
    217 
    218                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     195         mockRequest.setContextPath("/backend");
     196        mockRequest.setServletPath("/api");
     197        mockeryRest.checking(new Expectations() {
     198            {
     199               
     200                oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    219201
    220202                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("olhsha@mpi.nl");
     
    238220        Annotation newAnnotation = result.getValue().getAnnotation();
    239221        String actionName = result.getValue().getActionList().getAction().get(0).getMessage();
    240         assertEquals(addedAnnotation.getOwnerRef(), newAnnotation.getOwnerRef());
    241         assertEquals(addedAnnotation.getURI(), newAnnotation.getURI());
     222        assertEquals(addedAnnotation.getOwnerHref(), newAnnotation.getOwnerHref());
     223        assertEquals(addedAnnotation.getId(), newAnnotation.getId());
     224        assertEquals(addedAnnotation.getHref(), newAnnotation.getHref());
    242225        assertEquals(addedAnnotation.getHeadline(), newAnnotation.getHeadline());
    243226        assertEquals(addedAnnotation.getTargets(), newAnnotation.getTargets());
     
    252235        System.out.println("test updateAnnotation");
    253236
    254         final Annotation annotation = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationOne();
     237        final Annotation annotation = (new TestInstances("/backend/api")).getAnnotationOne();
    255238        annotation.getPermissions().setPublic(Access.READ);
    256239        annotation.setHeadline("updated annotation 1");
     
    269252
    270253        annotationResource.setHttpServletRequest(mockRequest);
    271         annotationResource.setUriInfo(mockUriInfo);
    272254        mockRequest.setRemoteUser("twagoo@mpi.nl");
    273         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    274 
     255        mockRequest.setContextPath("/backend");
     256        mockRequest.setServletPath("/api");
    275257        final UUID externalId = UUID.fromString("00000000-0000-0000-0000-000000000021");
    276258
     
    283265        mockeryRest.checking(new Expectations() {
    284266            {
    285                 oneOf(mockUriInfo).getBaseUri();
    286                 will(returnValue(baseUri));
    287 
    288                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     267                oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    289268
    290269                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("twagoo@mpi.nl");
    291                 will(returnValue(1));
    292                
    293                 oneOf(mockUriInfo).getBaseUri();
    294                 will(returnValue(baseUri));
    295 
     270                will(returnValue(1));               
     271               
    296272                oneOf(mockDbDispatcher).getResourceInternalIdentifier(externalId, Resource.ANNOTATION);
    297273                will(returnValue(1));
     
    316292        JAXBElement<ResponseBody> result = annotationResource.updateAnnotation("00000000-0000-0000-0000-000000000021", annotation);
    317293        Annotation newAnnotation = result.getValue().getAnnotation();
    318         assertEquals(annotation.getOwnerRef(), newAnnotation.getOwnerRef());
    319         assertEquals(annotation.getURI(), newAnnotation.getURI());
     294        assertEquals(annotation.getOwnerHref(), newAnnotation.getOwnerHref());
     295        assertEquals(annotation.getId(), newAnnotation.getId());
     296        assertEquals(annotation.getHref(), newAnnotation.getHref());
    320297        assertEquals("updated annotation 1", newAnnotation.getHeadline());
    321298        assertEquals("text/plain", newAnnotation.getBody().getTextBody().getMimeType());
     
    329306        System.out.println("test updateAnnotationBody");
    330307
    331         Annotation annotation = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationOne();
     308        Annotation annotation = (new TestInstances("/backend/api")).getAnnotationOne();
    332309       
    333310        final AnnotationBody ab = new AnnotationBody();
     
    344321
    345322        annotationResource.setHttpServletRequest(mockRequest);
    346         annotationResource.setUriInfo(mockUriInfo);
    347323        mockRequest.setRemoteUser("twagoo@mpi.nl");
    348         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    349 
     324        mockRequest.setContextPath("/backend");
     325        mockRequest.setServletPath("/api");
    350326        final UUID externalId = UUID.fromString("00000000-0000-0000-0000-000000000021");
    351327
     
    358334        mockeryRest.checking(new Expectations() {
    359335            {
    360                 oneOf(mockUriInfo).getBaseUri();
    361                 will(returnValue(baseUri));
    362 
    363                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     336               
     337                oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    364338
    365339                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("twagoo@mpi.nl");
     
    395369        System.out.println("test updateAnnotationHeadline");
    396370
    397         Annotation annotation = (new TestInstances(TestBackendConstants._TEST_SERVLET_URI)).getAnnotationOne();
     371        Annotation annotation = (new TestInstances("/api")).getAnnotationOne();
    398372       
    399373        final String newHeadline = "new Headline";       
     
    406380
    407381        annotationResource.setHttpServletRequest(mockRequest);
    408         annotationResource.setUriInfo(mockUriInfo);
    409382        mockRequest.setRemoteUser("twagoo@mpi.nl");
    410         final URI baseUri = URI.create(TestBackendConstants._TEST_SERVLET_URI);
    411 
     383        mockRequest.setContextPath("/backend");
     384        mockRequest.setServletPath("/api");
    412385        final UUID externalId = UUID.fromString("00000000-0000-0000-0000-000000000021");
    413386
     
    415388        mockeryRest.checking(new Expectations() {
    416389            {
    417                 oneOf(mockUriInfo).getBaseUri();
    418                 will(returnValue(baseUri));
    419 
    420                 oneOf(mockDbDispatcher).setServiceURI(baseUri.toString());
     390                 oneOf(mockDbDispatcher).setResourcesPaths("/backend/api");
    421391
    422392                oneOf(mockDbDispatcher).getPrincipalInternalIDFromRemoteID("twagoo@mpi.nl");
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/rest/AnnotationsTest.java

    r5203 r5385  
    7070    private JdbcTemplate jdbcTemplate;
    7171   
    72    
     72    String _relativePath = "/backend/api";
    7373   
    7474   
     
    8181                .requestListenerClass(RequestContextListener.class)
    8282                .contextListenerClass(ContextLoaderListener.class)
     83                .contextPath("/backend").servletPath("/api")
    8384                .build();
    8485       
     
    101102        jdbcTemplate.execute(JdbcResourceDaoTest.getNormalisedSql());
    102103        jdbcTemplate.execute(JdbcResourceDaoTest.getTestDataInsertSql());
     104       
    103105    }
    104106
     
    122124        // Getting annotation
    123125        System.out.println("testGetAnnotation");
    124         final String externalIDstring = "00000000-0000-0000-0000-000000000021";
    125         final Annotation testAnnotation = (new TestInstances(resource().getURI().toString())).getAnnotationOne();       
    126        
    127         final String requestUrl = "annotations/" + externalIDstring;
    128         System.out.println("requestUrl: " + requestUrl);
    129        
    130         Builder responseBuilder = getAuthenticatedResource(resource().path(requestUrl)).accept(MediaType.TEXT_XML);       
     126        final Annotation testAnnotation = (new TestInstances(_relativePath)).getAnnotationOne();       
     127       
     128        Builder responseBuilder = getAuthenticatedResource(resource().path("annotations/00000000-0000-0000-0000-000000000021")).accept(MediaType.TEXT_XML);       
    131129        ClientResponse response = responseBuilder.get(ClientResponse.class);       
    132130       
     
    136134        assertEquals(testAnnotation.getBody().getTextBody().getBody(), entity.getBody().getTextBody().getBody());
    137135        assertEquals(testAnnotation.getHeadline(), entity.getHeadline());
    138         assertEquals(testAnnotation.getOwnerRef(), entity.getOwnerRef());
     136        assertEquals(testAnnotation.getOwnerHref(), entity.getOwnerHref());
    139137        assertEquals(Access.WRITE, entity.getPermissions().getPublic());
    140138        assertEquals(3, entity.getPermissions().getPermission().size());
    141139        assertEquals("write", entity.getPermissions().getPermission().get(0).getLevel().value());
    142         assertEquals(resource().getURI()+"principals/"+"00000000-0000-0000-0000-000000000112", entity.getPermissions().getPermission().get(0).getPrincipalRef());
     140        assertEquals(_relativePath+"/principals/00000000-0000-0000-0000-000000000112", entity.getPermissions().getPermission().get(0).getPrincipalHref());
    143141        assertEquals("read", entity.getPermissions().getPermission().get(1).getLevel().value());
    144         assertEquals(resource().getURI()+"principals/"+"00000000-0000-0000-0000-000000000113", entity.getPermissions().getPermission().get(1).getPrincipalRef());
     142        assertEquals(_relativePath+"/principals/00000000-0000-0000-0000-000000000113", entity.getPermissions().getPermission().get(1).getPrincipalHref());
    145143        assertEquals("read", entity.getPermissions().getPermission().get(1).getLevel().value());
    146         assertEquals(resource().getURI()+"principals/"+"00000000-0000-0000-0000-000000000221", entity.getPermissions().getPermission().get(2).getPrincipalRef());
     144        assertEquals(_relativePath+"/principals/00000000-0000-0000-0000-000000000221", entity.getPermissions().getPermission().get(2).getPrincipalHref());
    147145        assertEquals(2, entity.getTargets().getTargetInfo().size());
    148         assertEquals(resource().getURI().toString()+"targets/"+"00000000-0000-0000-0000-000000000031", entity.getTargets().getTargetInfo().get(0).getRef());
    149         assertEquals(resource().getURI().toString()+"targets/"+"00000000-0000-0000-0000-000000000032", entity.getTargets().getTargetInfo().get(1).getRef());
     146        assertEquals(_relativePath+"/targets/00000000-0000-0000-0000-000000000031", entity.getTargets().getTargetInfo().get(0).getHref());
     147        assertEquals(_relativePath+"/targets/00000000-0000-0000-0000-000000000032", entity.getTargets().getTargetInfo().get(1).getHref());
    150148        assertEquals(testAnnotation.getLastModified(), entity.getLastModified());
    151         assertEquals(resource().getURI()+requestUrl, entity.getURI());
     149        assertEquals(_relativePath+"/annotations/00000000-0000-0000-0000-000000000021", entity.getHref());
    152150    }
    153151
     
    194192        System.out.println("test createAnnotation");
    195193        System.out.println("POST "+resource().getURI().toString()+"annotations/");
    196         final Annotation annotationToAdd = (new TestInstances(this.getBaseURI().toString())).getAnnotationToAdd();
     194       
     195        final Annotation annotationToAdd = (new TestInstances(_relativePath)).getAnnotationToAdd();
    197196        final JAXBElement<Annotation> jaxbElement = (new ObjectFactory()).createAnnotation(annotationToAdd);
    198197       
     
    208207        assertEquals(0, entityA.getPermissions().getPermission().size());
    209208        assertEquals(Access.WRITE, entityA.getPermissions().getPublic());
    210         assertEquals(this.getBaseURI() + "principals/00000000-0000-0000-0000-000000000113", entityA.getOwnerRef());
     209        assertEquals(_relativePath + "/principals/00000000-0000-0000-0000-000000000113", entityA.getOwnerHref());
    211210        assertEquals("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia#de_Opdracht", entityA.getTargets().getTargetInfo().get(0).getLink());
    212         assertEquals(this.getBaseURI()+ "targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getRef());
     211        assertEquals(_relativePath+ "/targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getHref());
    213212        assertEquals("version 1.0", entityA.getTargets().getTargetInfo().get(0).getVersion());
    214213       
     
    231230        System.out.println("test updateAnnotation");
    232231        System.out.println("PUT "+resource().getURI().toString()+"annotations/00000000-0000-0000-0000-000000000021");
    233         Annotation annotation = (new TestInstances(this.getBaseURI().toString())).getAnnotationOne();
     232               
     233        Annotation annotation = (new TestInstances(_relativePath)).getAnnotationOne();
    234234        annotation.getPermissions().setPublic(Access.READ);
    235235        annotation.setHeadline("updated annotation 1");
     
    254254        assertEquals(2, entityA.getPermissions().getPermission().size());
    255255        assertEquals(Access.READ, entityA.getPermissions().getPublic());
    256         assertEquals(this.getBaseURI() + "principals/00000000-0000-0000-0000-000000000111", entityA.getOwnerRef());
     256        assertEquals(_relativePath + "/principals/00000000-0000-0000-0000-000000000111", entityA.getOwnerHref());
    257257        assertEquals("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia#de_Opdracht", entityA.getTargets().getTargetInfo().get(0).getLink());
    258         assertEquals(this.getBaseURI()+ "targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getRef());
     258        assertEquals(_relativePath+ "/targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getHref());
    259259       
    260260    }
     
    297297        assertEquals(3, entityA.getPermissions().getPermission().size());
    298298        assertEquals(Access.WRITE , entityA.getPermissions().getPublic());
    299         assertEquals(this.getBaseURI() + "principals/00000000-0000-0000-0000-000000000111", entityA.getOwnerRef());
     299       
     300     
     301        assertEquals(_relativePath + "/principals/00000000-0000-0000-0000-000000000111", entityA.getOwnerHref());
    300302        assertEquals("http://nl.wikipedia.org/wiki/Sagrada_Fam%C3%ADlia#de_Opdracht", entityA.getTargets().getTargetInfo().get(0).getLink());
    301         assertEquals(this.getBaseURI()+ "targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getRef());
     303        assertEquals(_relativePath+ "/targets/00000000-0000-0000-0000-000000000031", entityA.getTargets().getTargetInfo().get(0).getHref());
    302304       
    303305    }
  • DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/rest/NotebookResourceTest.java

    r5145 r5385  
    3232@RunWith(value = SpringJUnit4ClassRunner.class)
    3333@ContextConfiguration(locations = {"/spring-test-config/mockeryRest.xml", "/spring-test-config/mockDBDispatcher.xml", "/spring-config/jaxbMarshallerFactory.xml",
    34     "/spring-config/jaxbUnmarshallerFactory.xml","/spring-test-config/mockUriInfo.xml"})
     34    "/spring-config/jaxbUnmarshallerFactory.xml"})
    3535public class NotebookResourceTest {
    3636
Note: See TracChangeset for help on using the changeset viewer.