Changeset 4523

Timestamp:

02/14/14 16:16:01 (10 years ago)

Author:

olhsha

Message:

Integrity service is adjusted and retested. Some REST methods fornotebooks are added (not tested)

Location:

DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src

Files:

• main/java/eu/dasish/annotation/backend/dao/DBIntegrityService.java (modified) (1 diff)
• main/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceImlp.java (modified) (4 diffs)
• main/java/eu/dasish/annotation/backend/rest/NotebookResource.java (modified) (3 diffs)
• test/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceTest.java (modified) (20 diffs)

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

@@ -240 +240 @@
 
     /// notebooks ///
-    public NotebookInfoList getNotebooks(Number prinipalID, Permission permission);
-
-    public NotebookInfoList getNotebooksOwnedBy(Number principalID);
-
-    public List<UUID> getPrincipals(Number notebookID, Permission permission);
-
-    public NotebookInfo getNotebookInfo(Number notebookID);
-
-    List<UUID> getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc);
+    
+    public Number getNotebookInternalIdentifier(UUID externalIdentifier);
+    
+    public NotebookInfoList getNotebooks(Number prinipalID, String permission);
+    
+    public ReferenceList getNotebooksOwnedBy(Number principalID);
+
+    public ReferenceList getPrincipals(Number notebookID, String permission);
+
+    public Notebook getNotebook(Number notebookID);
+
+    ReferenceList getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc);
 
     /**

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

@@ -438 +438 @@
     /// notebooks ///
     @Override
-    public NotebookInfoList getNotebooks(Number prinipalID, Permission permission) {
+     public Number getNotebookInternalIdentifier(UUID externalIdentifier){
+        return notebookDao.getInternalID(externalIdentifier);
+    }
+    
+    
+    @Override
+    public NotebookInfoList getNotebooks(Number principalID, String permission) {
         NotebookInfoList result = new NotebookInfoList();
-        List<Number> notebookIDs = notebookDao.getNotebookIDs(prinipalID, permission);
+        if (permission.equalsIgnoreCase("reader") || permission.equalsIgnoreCase("writer")) {
+            List<Number> notebookIDs = notebookDao.getNotebookIDs(principalID, Permission.fromValue(permission));
+            for (Number notebookID : notebookIDs) {
+                NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+                Number ownerID = notebookDao.getOwner(notebookID);
+                notebookInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
+                result.getNotebookInfo().add(notebookInfo);
+            }
+        } else {
+            if (permission.equalsIgnoreCase("owner")) {
+                List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
+                String ownerRef = userDao.getURIFromInternalID(principalID);
+                for (Number notebookID : notebookIDs) {
+                    NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+                    notebookInfo.setOwnerRef(ownerRef);
+                    result.getNotebookInfo().add(notebookInfo);
+                }
+            } else {
+                return null;
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public ReferenceList getNotebooksOwnedBy(Number principalID) {
+        ReferenceList result = new ReferenceList();
+        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
         for (Number notebookID : notebookIDs) {
-            NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
-            Number ownerID = notebookDao.getOwner(notebookID);
-            notebookInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
-            result.getNotebookInfo().add(notebookInfo);
-        }
-
-        return result;
-    }
-
-    @Override
-    public NotebookInfoList getNotebooksOwnedBy(Number principalID) {
-        NotebookInfoList result = new NotebookInfoList();
-        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
-        String ownerRef = userDao.getURIFromInternalID(principalID);
-        for (Number notebookID : notebookIDs) {
-            NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
-            notebookInfo.setOwnerRef(ownerRef);
-            result.getNotebookInfo().add(notebookInfo);
-        }
-
-        return result;
-    }
-
-    @Override
-    public List<UUID> getPrincipals(Number notebookID, Permission permission) {
-        List<UUID> result = new ArrayList<UUID>();
-        List<Number> principalIDs = notebookDao.getPrincipalIDsWithPermission(notebookID, permission);
+            String reference = notebookDao.getURIFromInternalID(notebookID);
+            result.getRef().add(reference);
+        }
+        return result;
+    }
+
+    @Override
+    public ReferenceList getPrincipals(Number notebookID, String permission) {
+        ReferenceList result = new ReferenceList();
+        List<Number> principalIDs = notebookDao.getPrincipalIDsWithPermission(notebookID, Permission.fromValue(permission));
         for (Number principalID : principalIDs) {
-            UUID uuid = userDao.getExternalID(principalID);
-            result.add(uuid);
-        }
-        return result;
-    }
-
-    @Override
-    public NotebookInfo getNotebookInfo(Number notebookID) {
-        NotebookInfo result = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+            String reference = userDao.getURIFromInternalID(principalID);
+            result.getRef().add(reference);
+        }
+        return result;
+    }
+
+    @Override
+    public Notebook getNotebook(Number notebookID) {
+        Notebook result = notebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(notebookID);
+
         result.setOwnerRef(userDao.getURIFromInternalID(notebookDao.getOwner(notebookID)));
+
+        ReferenceList annotations = new ReferenceList();
+        List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
+        for (Number annotationID : annotationIDs) {
+            annotations.getRef().add(annotationDao.getURIFromInternalID(annotationID));
+        }
+        result.setAnnotations(annotations);
+
+        UserWithPermissionList ups = new UserWithPermissionList();
+        List<Permission> permissions = new ArrayList<Permission>();
+        permissions.add(Permission.READER);
+        permissions.add(Permission.WRITER);
+        for (Permission permission : permissions) {
+            List<Number> users = notebookDao.getPrincipalIDsWithPermission(notebookID, permission);
+            if (users != null) {
+                for (Number user : users) {
+                    UserWithPermission up = new UserWithPermission();
+                    up.setRef(userDao.getURIFromInternalID(user));
+                    up.setPermission(permission);
+                    ups.getUserWithPermission().add(up);
+                }
+            }
+        }
+
+        result.setPermissions(ups);
         return result;
     }
@@ -485 +527 @@
     /////////////////////////////////////////////////////////////
     @Override
-    public List<UUID> getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc) {
+    public ReferenceList getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc) {
         List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
 
@@ -501 +543 @@
         String direction = desc ? "DESC" : "ASC";
         List<Number> selectedAnnotIDs = annotationDao.sublistOrderedAnnotationIDs(annotationIDs, offset, maximumAnnotations, orderedBy, direction);
-        List<UUID> annotationUUIDs = new ArrayList<UUID>();
+        ReferenceList references = new ReferenceList();
         for (Number annotationID : selectedAnnotIDs) {
-            annotationUUIDs.add(annotationDao.getExternalID(annotationID));
-        }
-        return annotationUUIDs;
+            references.getRef().add(annotationDao.getURIFromInternalID(annotationID));
+        }
+        return references;
     }
 
@@ -729 +771 @@
 
 ////////////// HELPERS ////////////////////
-private Target createFreshTarget(TargetInfo targetInfo) {
+    private Target createFreshTarget(TargetInfo targetInfo) {
         Target target = new Target();
         target.setLink(targetInfo.getLink());

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

@@ -18 +18 @@
 package eu.dasish.annotation.backend.rest;
 
+import eu.dasish.annotation.backend.BackendConstants;
 import eu.dasish.annotation.backend.dao.DBIntegrityService;
+import eu.dasish.annotation.schema.Notebook;
+import eu.dasish.annotation.schema.NotebookInfoList;
+import eu.dasish.annotation.schema.ObjectFactory;
+import eu.dasish.annotation.schema.ReferenceList;
 import java.io.IOException;
+import java.net.URI;
 import java.sql.SQLException;
+import java.util.UUID;
 import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.UriInfo;
 import javax.ws.rs.ext.Providers;
+import javax.xml.bind.JAXBElement;
 import javax.xml.parsers.ParserConfigurationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -38 +54 @@
 @Component
 @Path("/notebooks")
-@Transactional(rollbackFor={Exception.class, SQLException.class, IOException.class, ParserConfigurationException.class})
+@Transactional(rollbackFor = {Exception.class, SQLException.class, IOException.class, ParserConfigurationException.class})
 public class NotebookResource {
 
@@ -45 +61 @@
     @Context
     private HttpServletRequest httpServletRequest;
-    
+    @Context
+    private HttpServletResponse httpServletResponse;
     @Context
     private UriInfo uriInfo;
-    
     @Context
     protected Providers providers;
+    private final Logger logger = LoggerFactory.getLogger(AnnotationResource.class);
+    private final Logger loggerServer = LoggerFactory.getLogger(HttpServletResponse.class);
 
-//    @GET
-//    @Produces(MediaType.TEXT_XML)
-//    @Path("")
-//    // Returns notebook-infos for the notebooks accessible to the current user.
-//    public JAXBElement<NotebookInfoList> getNotebookInfo(@Context HttpServletRequest httpServletRequest) {
-//        final NotebookInfoList notebookInfoList = new NotebookInfoList();
-//        String remoteUser = httpServletRequest.getRemoteUser();
-//        UUID remoteUserUUID = (remoteUser != null) ? UUID.fromString(remoteUser) : null;
-//        notebookInfoList.getNotebook().addAll(notebookDao.getNotebookInfos(remoteUserUUID));
-//        return new ObjectFactory().createNotebookInfoList(notebookInfoList);
-//    }
-//
-//    @GET
-//    @Produces(MediaType.TEXT_XML)
-//    @Path("test")
-//    // This is not in the standards definition and is only used for testing
-//    public JAXBElement<NotebookInfoList> getNotebookInfo(@QueryParam("userid") String userId) {
-//        final NotebookInfoList notebookInfos = new NotebookInfoList();
-//        notebookInfos.getNotebook().addAll(notebookDao.getNotebookInfos(UUID.fromString(userId)));
-//        return new ObjectFactory().createNotebookInfoList(notebookInfos);
-//    }
-//
-//    @GET
-//    @Produces(MediaType.TEXT_XML)
-//    @Path("owned")
-//    // Returns the list of all notebooks owned by the current logged user.
-//    public List<Notebook> getUsersNotebooks(@Context HttpServletRequest httpServletRequest) {
-//        // todo: sort out how the user id is obtained and how it is stored it the db
-//        String remoteUser = httpServletRequest.getRemoteUser();
-//        UUID remoteUserUUID = (remoteUser != null) ? UUID.fromString(remoteUser) : null;
-//        return notebookDao.getUsersNotebooks(remoteUserUUID);
-//    }
-//
-//    @GET
-//    @Produces("text/html")
-//    @Path("{notebookid: [a-zA-Z0-9_]*}/readers")
-//    // Returns the list of _uid_ who allowed to read the annotations from notebook.
-//    public String getReaders(@PathParam("notebookid") String notebookId) {
-//        return "readers for " + notebookId;
-//    }
-//
-//    @GET
-//    @Produces("text/html")
-//    @Path("{notebookid: [a-zA-Z0-9_]*}/writers")
-//    // Returns the list of _uid_ that can add annotations to the notebook.
-//    public String getWriters(@PathParam("notebookid") String notebookId) {
-//        return "writers for " + notebookId;
-//    }
-//
-//    @GET
-//    @Produces(MediaType.TEXT_XML)
-//    @Path("{notebookid: " + BackendConstants.regExpIdentifier + "}/metadata")
-//    // Get all metadata about a specified notebook _nid_, including the information if it is private or not.
-//    public JAXBElement<NotebookInfo> getMetadata(@PathParam("notebookid") String notebookId) {
-//        NotebookInfo result = notebookDao.getNotebookInfo(notebookDao.getInternalID(UUID.fromString(notebookId)));
-//        // TODO change the name of the create method to createNotebookInfo!
-//        return new ObjectFactory().createNotebookInfo(result);
-//
-//    }
-//
-//    @GET
-//    @Path("{notebookid: " + BackendConstants.regExpIdentifier + "}")
-//    /*
-//     * Get the list of all annotations _aid_-s contained within a Notebook with related metadata. 
-//     * Parameters: _nid_, 
-//     * optional maximumAnnotations specifies the maximum number of annotations to retrieve (default -1, all annotations), 
-//     * optional startAnnotation specifies the starting point from which the annotations will be retrieved (default: -1, start from the first annotation), 
-//     * optional orderby, specifies the RDF property used to order the annotations (default: dc:created ), 
-//     * optional orderingMode specifies if the results should be sorted using a descending order desc=1 or an ascending order desc=0 (default: 0 ).
-//     * */
-//    @Produces(MediaType.TEXT_XML)
-//    public List<JAXBElement<UUID>> getAllAnnotations(@PathParam("notebookid") String notebookId, @DefaultValue("-1") @QueryParam(value = "maximumAnnotations") final int maximumAnnotations,
-//            @DefaultValue("-1") @QueryParam(value = "startAnnotation") final int startAnnotation,
-//            @DefaultValue("dc:created") @QueryParam(value = "orderby") final String orderby,
-//            @DefaultValue("0") @QueryParam(value = "orderingMode") final int orderingMode) {
-//        UUID notebookUUID = UUID.fromString(notebookId);
-//        List<UUID> annotationIDs = notebookDao.getAnnotationExternalIDs(notebookUUID);
-//        List<JAXBElement<UUID>> result = new ArrayList<JAXBElement<UUID>>();
-//        for (UUID annotationID : annotationIDs) {
-//            final JAXBElement<UUID> jaxbElement = new JAXBElement<UUID>(new QName("http://www.dasish.eu/ns/addit", "uuid"), UUID.class, null, annotationID);
-//            result.add(jaxbElement);
-//        }
-//        return result;
-//        // TODO implement optional parameters!!
-//    }
-//
-//    @PUT
-//    @Path("{notebookid: [a-zA-Z0-9_]*}")
-//    @Consumes(MediaType.APPLICATION_XML)
-//    /*
-//     Modify metadata of _nid_. The new notebook?s name must be sent in request?s body.
-//     */
-//    public String modifyNotebook(@PathParam("notebookid") String notebookId, Notebook notebook) {
-//        return "modifyNotebook " + notebookId + notebook.getTitle();
-//    }
-//
-//    @PUT
-//    @Path("{notebookid: [a-zA-Z0-9_]*}/{annotationid: [a-zA-Z0-9_]*}")
-//    /*
-//     Adds an annotation _aid_ to the list of annotations of _nid_.
-//     */
-//    public String addAnnotation(@PathParam("notebookid") String notebookId, @PathParam("annotationid") String annotationId) {
-//        return "addAnnotation " + notebookId + " : " + annotationId;
-//    }
-//
-////    @PUT
-////    @Path("{notebookid: [a-zA-Z0-9_]*}/setPrivate={isPrivate: true|false}")
-////    /*
-////     Sets the specified Notebook as private or not private.
-////     */
-////    public String setPrivate(@PathParam("notebookid") String notebookId, @PathParam("isPrivate") String isPrivate) {
-////        return "modifyNotebook " + notebookId + " : " + isPrivate;
-////    }
-//    @POST
-//    @Path("")
-//    /*
-//     * Creates a new notebook. 
-//     * This API returns the _nid_ of the created Notebook in response?s payload and the full URL of the notebook adding a Location header into the HTTP response. 
-//     * The name of the new notebook can be specified sending a specific payload.
-//     */
-//    public String createNotebook(@Context HttpServletRequest httpServletRequest) throws URISyntaxException {
-//        String remoteUser = httpServletRequest.getRemoteUser();
-//        UUID remoteUserUUID = (remoteUser != null) ? UUID.fromString(remoteUser) : null;
-//        UUID notebookId = notebookDao.addNotebook(remoteUserUUID, null);
-//        final URI serverUri = new URI(httpServletRequest.getRequestURL().toString());
-//        String fullUrlString = "/api/notebooks/" + notebookId.toString();
-//        return serverUri.resolve(fullUrlString).toString();
-//    }
-//
-//    @POST
-//    @Path("{notebookid: [a-zA-Z0-9_]*}")
-//    /*
-//     * Creates a new annotation in _nid_. 
-//     * The content of an annotation is given in the request body. In fact this is a short cut of two actions:
-//     */
-//    public String createAnnotation() {
-//        String notebookId = "_nid_";
-//        String fullUrlString = "api/notebooks/_nid_";
-//        return "annotation " + notebookId + " : " + fullUrlString;
-//    }
-//
-//    @DELETE
-//    @Path("{notebookid: [a-zA-Z0-9_-]*}")
-//    /*
-//     Delete _nid_. Annotations stay, they just lose connection to _nid_.<br>
-//     */
-//    public String deleteNotebook(@PathParam("notebookid") UUID notebookId) {
-//        // todo: sort out how the id string passsed in here is mapped eg db column for _nid_
-//        return Integer.toString(notebookDao.deleteNotebook(notebookId));
-//    }
+    public NotebookResource() {
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_XML)
+    @Path("")
+    @Transactional(readOnly = true)
+    public JAXBElement<NotebookInfoList> getNotebookInfos(@QueryParam("permission") String permissionMode) throws IOException {
+
+        URI baseURI = uriInfo.getBaseUri();
+        String baseURIstr = baseURI.toString();
+        dbIntegrityService.setServiceURI(baseURIstr);
+
+        String remoteUser = httpServletRequest.getRemoteUser();
+        final Number userID = dbIntegrityService.getUserInternalIDFromRemoteID(remoteUser);
+        if (userID != null) {
+            if (permissionMode.equalsIgnoreCase("reader") || permissionMode.equalsIgnoreCase("writer") || permissionMode.equalsIgnoreCase("owner")) {
+                NotebookInfoList notebookInfos = dbIntegrityService.getNotebooks(userID, permissionMode);
+                return new ObjectFactory().createNotebookInfoList(notebookInfos);
+            } else {
+                loggerServer.debug(httpServletResponse.SC_BAD_REQUEST + ": '" + permissionMode + "' is an invalid permission value, which must be either owner, or reader, or writer.");
+                httpServletResponse.sendError(httpServletResponse.SC_BAD_REQUEST, permissionMode + "' is an invalid permission value, which must be either owner, or reader, or writer.");
+                return null;
+            }
+        } else {
+            loggerServer.debug(httpServletResponse.SC_NOT_FOUND + ": the logged-in user is not found in the database");
+            httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "The logged-in user is not found in the database");
+            return null;
+        }
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_XML)
+    @Path("owned")
+    @Transactional(readOnly = true)
+    public JAXBElement<ReferenceList> getOwnedNotebooks() throws IOException {
+
+        URI baseURI = uriInfo.getBaseUri();
+        String baseURIstr = baseURI.toString();
+        dbIntegrityService.setServiceURI(baseURIstr);
+
+        String remoteUser = httpServletRequest.getRemoteUser();
+        final Number userID = dbIntegrityService.getUserInternalIDFromRemoteID(remoteUser);
+        if (userID != null) {
+            ReferenceList references = dbIntegrityService.getNotebooksOwnedBy(userID);
+            return new ObjectFactory().createReferenceList(references);
+        } else {
+            loggerServer.debug(httpServletResponse.SC_NOT_FOUND + ": the logged-in user is not found in the database");
+            httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "The logged-in user is not found in the database");
+            return null;
+        }
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_XML)
+    @Path("{notebookid: " + BackendConstants.regExpIdentifier + "}/targets")
+    @Transactional(readOnly = true)
+    public JAXBElement<Notebook> getNotebook(@PathParam("notebookid") String externalIdentifier) throws IOException {
+
+        URI baseURI = uriInfo.getBaseUri();
+        String baseURIstr = baseURI.toString();
+        dbIntegrityService.setServiceURI(baseURIstr);
+
+        String remoteUser = httpServletRequest.getRemoteUser();
+        final Number userID = dbIntegrityService.getUserInternalIDFromRemoteID(remoteUser);
+        if (userID != null) {
+            Number notebookID = dbIntegrityService.getNotebookInternalIdentifier(UUID.fromString(externalIdentifier));
+            if (notebookID != null) {
+                Notebook notebook = dbIntegrityService.getNotebook(notebookID);
+                return new ObjectFactory().createNotebook(notebook);
+            } else {
+                loggerServer.debug(HttpServletResponse.SC_NOT_FOUND + ": The notebook with the given id " + externalIdentifier + " is not found in the database");
+                httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "The notebook with the given id " + externalIdentifier + " is not found in the database");
+                return null;
+            }
+        } else {
+            loggerServer.debug(httpServletResponse.SC_NOT_FOUND + ": the logged-in user is not found in the database");
+            httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "The logged-in user is not found in the database");
+            return null;
+        }
+    }
 }

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

@@ -50 +50 @@
 import java.util.UUID;
 import javax.sql.rowset.serial.SerialException;
+import javax.xml.datatype.DatatypeConfigurationException;
 import javax.xml.datatype.DatatypeFactory;
 import javax.xml.datatype.XMLGregorianCalendar;
@@ -825 +826 @@
      * Getters
      */
-    /// notebooks ///
-    //public NotebookInfoList getNotebooks(Number prinipalID, Permission permission);
-//     NotebookInfoList result = new NotebookInfoList();
-//        List<Number> notebookIDs = notebookDao.getNotebookIDs(prinipalID, permission);
-//        for (Number notebookID : notebookIDs) {
-//            NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
-//            Number ownerID = notebookDao.getOwner(notebookID);
-//            notebookInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
-//            result.getNotebookInfo().add(notebookInfo);
+   
+//     public Number getNotebookInternalIdentifier(UUID externalIdentifier){
+//        return notebookDao.getInternalID(externalIdentifier);
+//    }
+    
+    @Test
+    public void testGetNotebookInternalIdentifier() {
+        
+        final UUID mockUUID = UUID.fromString("00000000-0000-0000-0000-000000000021");
+        
+        mockeryDao.checking(new Expectations() {
+            {
+                oneOf(notebookDao).getInternalID(mockUUID);
+                will(returnValue(1));
+            }
+        });
+
+       assertEquals(1, dbIntegrityService.getNotebookInternalIdentifier(mockUUID));
+    
+    }  
+       
+    
+    
+//    public NotebookInfoList getNotebooks(Number principalID, String permission) {
+//        NotebookInfoList result = new NotebookInfoList();
+//        if (permission.equalsIgnoreCase("reader") || permission.equalsIgnoreCase("writer")) {
+//            List<Number> notebookIDs = notebookDao.getNotebookIDs(principalID, Permission.fromValue(permission));
+//            for (Number notebookID : notebookIDs) {
+//                NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+//                Number ownerID = notebookDao.getOwner(notebookID);
+//                notebookInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
+//                result.getNotebookInfo().add(notebookInfo);
+//            }
+//        } else {
+//            if (permission.equalsIgnoreCase("owner")) {
+//                List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
+//                String ownerRef = userDao.getURIFromInternalID(principalID);
+//                for (Number notebookID : notebookIDs) {
+//                    NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+//                    notebookInfo.setOwnerRef(ownerRef);
+//                    result.getNotebookInfo().add(notebookInfo);
+//                }
+//            } else {
+//                return null;
+//            }
 //        }
-//
 //        return result;
-    @Test
-    public void testGetNotebooks() {
+//    }
+    @Test
+    public void testGetNotebooksReaderBranch() {
 
         final List<Number> mockNotebookIDs = new ArrayList<Number>();
@@ -864 +901 @@
         });
 
-        NotebookInfoList result = dbIntegrityService.getNotebooks(3, Permission.READER);
+        NotebookInfoList result = dbIntegrityService.getNotebooks(3, "reader");
         assertEquals("00000000-0000-0000-0000-000000000011", result.getNotebookInfo().get(0).getRef());
         assertEquals("00000000-0000-0000-0000-000000000111", result.getNotebookInfo().get(0).getOwnerRef());
@@ -871 +908 @@
     }
 
-    ;
-    
-
-    /*public NotebookInfoList getNotebooksOwnedBy(Number principalID){
-        NotebookInfoList result = new NotebookInfoList();
-        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
-        String ownerRef = userDao.getURIFromInternalID(principalID);
-        for (Number notebookID : notebookIDs) {
-            NotebookInfo notebookInfo = notebookDao.getNotebookInfoWithoutOwner(notebookID);
-            notebookInfo.setOwnerRef(ownerRef);
-            result.getNotebookInfo().add(notebookInfo);
-        }
-
-        return result;
-    }*/
-    
-    @Test
-    public void testGetNotebooksOwnedBy() {
+    @Test
+    public void testGetNotebooksOwnerBranch() {
 
         final List<Number> mockNotebookIDs = new ArrayList<Number>();
@@ -919 +940 @@
         });
 
-        NotebookInfoList result = dbIntegrityService.getNotebooksOwnedBy(3);
+        NotebookInfoList result = dbIntegrityService.getNotebooks(3, "owner");
         assertEquals("00000000-0000-0000-0000-000000000013", result.getNotebookInfo().get(0).getRef());
         assertEquals("00000000-0000-0000-0000-000000000113", result.getNotebookInfo().get(0).getOwnerRef());
@@ -929 +950 @@
     }
 
-    ;
-
+//    public ReferenceList getNotebooksOwnedBy(Number principalID) {
+//        ReferenceList result = new ReferenceList();
+//        List<Number> notebookIDs = notebookDao.getNotebookIDsOwnedBy(principalID);
+//        for (Number notebookID : notebookIDs) {
+//            String reference = notebookDao.getURIFromInternalID(notebookID);
+//            result.getRef().add(reference);
+//        }
+//        return result;
+//    }
+    @Test
+    public void testGetNotebooksOwnedBy() {
+
+        final List<Number> mockNotebookIDs = new ArrayList<Number>();
+        mockNotebookIDs.add(3);
+        mockNotebookIDs.add(4);
+
+        mockeryDao.checking(new Expectations() {
+            {
+                oneOf(notebookDao).getNotebookIDsOwnedBy(3);
+                will(returnValue(mockNotebookIDs));
+
+                oneOf(notebookDao).getURIFromInternalID(3);
+                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013"));
+
+                oneOf(notebookDao).getURIFromInternalID(4);
+                will(returnValue(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014"));
+
+            }
+        });
+
+        ReferenceList result = dbIntegrityService.getNotebooksOwnedBy(3);
+        assertEquals(2, result.getRef().size());
+        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000013", result.getRef().get(0));
+        assertEquals(TestBackendConstants._TEST_SERVLET_URI_notebooks + "00000000-0000-0000-0000-000000000014", result.getRef().get(1));
+    }
 
     /*
-     public List<UUID> getPrincipals(Number notebookID, Permission permission) {
-        List<UUID> result = new ArrayList<UUID>();
-        List<Number> principalIDs = notebookDao.getPrincipalIDsWithPermission(notebookID, permission);
+     public ReferenceList getPrincipals(Number notebookID, String permission) {
+        ReferenceList result = new ReferenceList();
+        List<Number> principalIDs = notebookDao.getPrincipalIDsWithPermission(notebookID, Permission.fromValue(permission));
         for (Number principalID : principalIDs) {
-            UUID uuid = userDao.getExternalID(principalID);
-            result.add(uuid);
+            String reference = userDao.getURIFromInternalID(principalID);
+            result.getRef().add(reference);
         }
         return result;
-    }*/
-    
+    }
+     }*/
     @Test
     public void testGetPrincipals() {
@@ -948 +1002 @@
         mockPrincipalIDs.add(2);
         mockPrincipalIDs.add(4);
-
-        final NotebookInfo mockNotebookInfo = new NotebookInfo();
-        mockNotebookInfo.setRef("00000000-0000-0000-0000-000000000011");
-        mockNotebookInfo.setTitle("Notebook 1");
-
+        
         mockeryDao.checking(new Expectations() {
             {
@@ -958 +1008 @@
                 will(returnValue(mockPrincipalIDs));
 
-                oneOf(userDao).getExternalID(2);
-                will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000112")));
-                
-                 oneOf(userDao).getExternalID(4);
-                will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000114")));
-                
-
-            }
-        });
-
-        List<UUID> result = dbIntegrityService.getPrincipals(1, Permission.WRITER);
-        assertEquals("00000000-0000-0000-0000-000000000112", result.get(0).toString());
-        assertEquals("00000000-0000-0000-0000-000000000114", result.get(1).toString());
-
-    }
-    
-    
-//    public NotebookInfo getNotebookInfo(Number notebookID) {
-//        NotebookInfo result = notebookDao.getNotebookInfoWithoutOwner(notebookID);
+                oneOf(userDao).getURIFromInternalID(2);
+                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000112"));
+
+                oneOf(userDao).getURIFromInternalID(4);
+                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000114"));
+
+
+            }
+        });
+
+        ReferenceList result = dbIntegrityService.getPrincipals(1, "writer");
+        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000112", result.getRef().get(0).toString());
+        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000114", result.getRef().get(1).toString());
+
+    }
+
+//   @Override
+//    public Notebook getNotebook(Number notebookID) {
+//        Notebook result = notebookDao.getNotebookWithoutAnnotationsAndPermissionsAndOwner(notebookID);
+//
 //        result.setOwnerRef(userDao.getURIFromInternalID(notebookDao.getOwner(notebookID)));
+//
+//        ReferenceList annotations = new ReferenceList();
+//        List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
+//        for (Number annotationID : annotationIDs) {
+//            annotations.getRef().add(annotationDao.getURIFromInternalID(annotationID));
+//        }
+//        result.setAnnotations(annotations);
+//
+//        UserWithPermissionList ups = new UserWithPermissionList();
+//        List<Permission> permissions = new ArrayList<Permission>();
+//        permissions.add(Permission.READER);
+//        permissions.add(Permission.WRITER);
+//        for (Permission permission : permissions) {
+//            List<Number> users = notebookDao.getPrincipalIDsWithPermission(notebookID, permission);
+//            if (users != null) {
+//                for (Number user : users) {
+//                    UserWithPermission up = new UserWithPermission();
+//                    up.setRef(userDao.getURIFromInternalID(user));
+//                    up.setPermission(permission);
+//                    ups.getUserWithPermission().add(up);
+//                }
+//            }
+//        }
+//
+//        result.setPermissions(ups);
 //        return result;
 //    }
-    
-  
-    @Test
-    public void testGetNotebookInfo() {
-
-        final NotebookInfo mockNotebookInfo = new NotebookInfo();
-        mockNotebookInfo.setRef("00000000-0000-0000-0000-000000000011");
-        mockNotebookInfo.setTitle("Notebook 1");
-
-        mockeryDao.checking(new Expectations() {
-            {
-                oneOf(notebookDao).getNotebookInfoWithoutOwner(1);
-                will(returnValue(mockNotebookInfo));
+
+
+    @Test
+    public void testGetNotebook() throws DatatypeConfigurationException{
+
+        final Notebook mockNotebook = new Notebook();
+        mockNotebook.setURI("serviceURI/notebooks/00000000-0000-0000-0000-000000000012");
+        mockNotebook.setTitle("Notebook 2");
+        mockNotebook.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar("2014-02-12T09:25:00.383000Z"));
+        
+        final List<Number> mockAnnotations = new ArrayList<Number>();
+        mockAnnotations.add(3);
+        
+        final List<Number> mockReaders = new ArrayList<Number>();
+        mockReaders.add(1);
+        
+        final List<Number> mockWriters = new ArrayList<Number>();
+        mockWriters.add(3);
+        
+        mockeryDao.checking(new Expectations() {
+            {
+                oneOf(notebookDao).getNotebookWithoutAnnotationsAndPermissionsAndOwner(2);
+                will(returnValue(mockNotebook));
+
+                oneOf(notebookDao).getOwner(2);
+                will(returnValue(2));
+
+                oneOf(userDao).getURIFromInternalID(2);
+                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000112"));
+
+                oneOf(notebookDao).getAnnotations(2);
+                will(returnValue(mockAnnotations));
                 
-                oneOf(notebookDao).getOwner(1);
-                will(returnValue(1));
-
+                oneOf(annotationDao).getURIFromInternalID(3);
+                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000023"));
+                
+                oneOf(notebookDao).getPrincipalIDsWithPermission(2, Permission.READER);
+                will(returnValue(mockReaders));
+                
                 oneOf(userDao).getURIFromInternalID(1);
-                will(returnValue("00000000-0000-0000-0000-000000000111"));
+                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000111"));
                 
-
-            }
-        });
-
-        NotebookInfo result = dbIntegrityService.getNotebookInfo(1);
-        assertEquals("00000000-0000-0000-0000-000000000011", result.getRef());
-        assertEquals("00000000-0000-0000-0000-000000000111", result.getOwnerRef());
-        assertEquals("Notebook 1", result.getTitle());
-
-    }
-    
-    
+                oneOf(notebookDao).getPrincipalIDsWithPermission(2, Permission.WRITER);
+                will(returnValue(mockWriters));
+                
+                oneOf(userDao).getURIFromInternalID(3);
+                will(returnValue("serviceURI/users/00000000-0000-0000-0000-000000000113"));
+
+                
+
+            }
+        });
+
+        Notebook result = dbIntegrityService.getNotebook(2);
+        assertEquals("serviceURI/notebooks/00000000-0000-0000-0000-000000000012", result.getURI());
+        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000112", result.getOwnerRef());
+        assertEquals("2014-02-12T09:25:00.383000Z", result.getLastModified().toString());
+        assertEquals("Notebook 2", result.getTitle());
+        assertEquals(1, result.getAnnotations().getRef().size());
+        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000023", result.getAnnotations().getRef().get(0));
+        assertEquals(2, result.getPermissions().getUserWithPermission().size());
+        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000111", result.getPermissions().getUserWithPermission().get(0).getRef());
+        assertEquals("reader", result.getPermissions().getUserWithPermission().get(0).getPermission().value());
+        assertEquals("serviceURI/users/00000000-0000-0000-0000-000000000113", result.getPermissions().getUserWithPermission().get(1).getRef());
+        assertEquals("writer", result.getPermissions().getUserWithPermission().get(1).getPermission().value());
+        
+    }
+
 //    public List<UUID> getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc) {
 //        List<Number> annotationIDs = notebookDao.getAnnotations(notebookID);
@@ -1034 +1146 @@
 //        return annotationUUIDs;
 //    }
-    
-    
     @Test
     public void testAnnotationsForNotebook() {
@@ -1046 +1156 @@
                 oneOf(notebookDao).getAnnotations(1);
                 will(returnValue(mockAnnotationIDs));
-                
+
                 oneOf(annotationDao).sublistOrderedAnnotationIDs(mockAnnotationIDs, 0, 3, "last_modified", "DESC");
                 will(returnValue(mockAnnotationIDs));
 
-                oneOf(annotationDao).getExternalID(1);
-                will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000021")));
-                
-                oneOf(annotationDao).getExternalID(2);
-                will(returnValue(UUID.fromString("00000000-0000-0000-0000-000000000022")));
-                
-
-            }
-        });
-
-        List<UUID> result = dbIntegrityService.getAnnotationsForNotebook(1, -1, 3, "last_modified", true);
-        assertEquals("00000000-0000-0000-0000-000000000021", result.get(0).toString());
-        assertEquals("00000000-0000-0000-0000-000000000022", result.get(1).toString());
-
-    }
-    
-    
-    /**
- * Updaters
- */
-  
+                oneOf(annotationDao).getURIFromInternalID(1);
+                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000021"));
+
+                oneOf(annotationDao).getURIFromInternalID(2);
+                will(returnValue("serviceURI/annotations/00000000-0000-0000-0000-000000000022"));
+
+
+
+            }
+        });
+
+        ReferenceList result = dbIntegrityService.getAnnotationsForNotebook(1, -1, 3, "last_modified", true);
+        assertEquals(2, result.getRef().size());
+        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000021", result.getRef().get(0).toString());
+        assertEquals("serviceURI/annotations/00000000-0000-0000-0000-000000000022", result.getRef().get(1).toString());
+
+    }
+
+    /**
+     * Updaters
+     */
 //    public boolean updateNotebookMetadata(Number notebookID, NotebookInfo upToDateNotebookInfo) {
 //        Number ownerID = userDao.getInternalIDFromURI(upToDateNotebookInfo.getOwnerRef());
 //        return notebookDao.updateNotebookMetadata(notebookID, upToDateNotebookInfo.getTitle(), ownerID);
 //    }
-    
-    
-    @Test
-    public void testUpdateNotebookMetadata() {        
-        
-        final NotebookInfo mockNotebookInfo= new NotebookInfo();
-        mockNotebookInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_users+"00000000-0000-0000-0000-000000000113");
+    @Test
+    public void testUpdateNotebookMetadata() {
+
+        final NotebookInfo mockNotebookInfo = new NotebookInfo();
+        mockNotebookInfo.setOwnerRef(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
         mockNotebookInfo.setTitle("New Title");
 
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users+"00000000-0000-0000-0000-000000000113");
+                oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
                 will(returnValue(3));
-                
+
                 oneOf(notebookDao).updateNotebookMetadata(1, "New Title", 3);
                 will(returnValue(true));
@@ -1096 +1204 @@
         boolean result = dbIntegrityService.updateNotebookMetadata(1, mockNotebookInfo);
         assertTrue(result);
-    } 
-    
+    }
 
 // 
@@ -1103 +1210 @@
 //        return notebookDao.addAnnotationToNotebook(notebookID, annotationID);
 //    }
-
-    @Test
-    public void testAddAnnotationToNotebook() {        
-        
-        mockeryDao.checking(new Expectations() {
-            {
-               
+    @Test
+    public void testAddAnnotationToNotebook() {
+
+        mockeryDao.checking(new Expectations() {
+            {
+
                 oneOf(notebookDao).addAnnotationToNotebook(1, 3);
                 will(returnValue(true));
@@ -1115 +1221 @@
         });
 
-        assertTrue(dbIntegrityService.addAnnotationToNotebook(1,3));
-    } 
-    
-    
-/**
- * Adders
- */
-
+        assertTrue(dbIntegrityService.addAnnotationToNotebook(1, 3));
+    }
+
+    /**
+     * Adders
+     */
 //    public Number createNotebook(Notebook notebook, Number ownerID) {
 //        Number notebookID = notebookDao.createNotebookWithoutPermissionsAndAnnotations(notebook, ownerID);
@@ -1134 +1238 @@
 //        return notebookID;
 //    }
-
-    
     @Test
     public void testCreateNotebook() {
-        
+
         final Notebook notebook = new Notebook();
         notebook.setOwnerRef("tmpXXX");
         notebook.setTitle("(Almost) Copy of Notebook 1");
-        notebook.setURI("tmpYYY");        
-        
+        notebook.setURI("tmpYYY");
+
         UserWithPermissionList permissions = new UserWithPermissionList();
         UserWithPermission p1 = new UserWithPermission();
@@ -1154 +1256 @@
         permissions.getUserWithPermission().add(p2);
         notebook.setPermissions(permissions);
-        
+
         mockeryDao.checking(new Expectations() {
             {
                 oneOf(notebookDao).createNotebookWithoutPermissionsAndAnnotations(notebook, 1);
                 will(returnValue(5));
-                
+
                 oneOf(notebookDao).setOwner(5, 1);
                 will(returnValue(true));
-                
+
                 oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000112");
                 will(returnValue(2));
-                
+
                 oneOf(userDao).getInternalIDFromURI(TestBackendConstants._TEST_SERVLET_URI_users + "00000000-0000-0000-0000-000000000113");
                 will(returnValue(3));
-                
-               oneOf(notebookDao).addPermissionToNotebook(5, 2, Permission.WRITER);
-               will(returnValue(true));
-                
+
+                oneOf(notebookDao).addPermissionToNotebook(5, 2, Permission.WRITER);
+                will(returnValue(true));
+
                 oneOf(notebookDao).addPermissionToNotebook(5, 3, Permission.READER);
-               will(returnValue(true));
-               
+                will(returnValue(true));
+
             }
         });
@@ -1182 +1284 @@
 
     }
-      
-    
-    
-    
+
 //    public boolean createAnnotationInNotebook(Number notebookID, Annotation annotation, Number ownerID) {
 //        Number newAnnotationID = this.addUsersAnnotation(ownerID, annotation);
 //        return notebookDao.addAnnotationToNotebook(notebookID, newAnnotationID);
 //    }
-   
     @Test
     public void testCreateAnnotationInNotebook() {
-        
+
         final Annotation testAnnotation = testInstances.getAnnotationToAdd();
-        
+
         mockeryDao.checking(new Expectations() {
             {
@@ -1212 +1310 @@
 
                 /////////////////////////
-                
+
                 oneOf(notebookDao).addAnnotationToNotebook(1, 5);
                 will(returnValue(true));
@@ -1220 +1318 @@
         assertTrue(dbIntegrityService.createAnnotationInNotebook(1, testAnnotation, 3));
 
-    }   
-
-/**
- * Deleters
- */
-    
+    }
+
+    /**
+     * Deleters
+     */
 //      public boolean deleteNotebook(Number notebookID) {
 //        if (notebookDao.deleteAllPermissionsForNotebook(notebookID) || notebookDao.deleteAllAnnotationsFromNotebook(notebookID)) {
@@ -1234 +1331 @@
 //   
 //   }
-    
-    @Test
-    public void testDeleteNotebook() {        
-        
-        mockeryDao.checking(new Expectations() {
-            {
-               
+    @Test
+    public void testDeleteNotebook() {
+
+        mockeryDao.checking(new Expectations() {
+            {
+
                 oneOf(notebookDao).deleteAllPermissionsForNotebook(1);
                 will(returnValue(true));
-                
+
                 oneOf(notebookDao).deleteAllAnnotationsFromNotebook(1);
                 will(returnValue(true));
-                
+
                 oneOf(notebookDao).deleteNotebook(1);
                 will(returnValue(true));
@@ -1253 +1349 @@
 
         assertTrue(dbIntegrityService.deleteNotebook(1));
-    } 
-    
+    }
 }