Changeset 3909

Timestamp:

10/29/13 15:30:29 (11 years ago)

Author:

olhsha

Message:

Refactoring + debugging updating permission lists for an annotation. Works (PUT)

Location:

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

Files:

• main/java/eu/dasish/annotation/backend/dao/AnnotationDao.java (modified) (1 diff)
• main/java/eu/dasish/annotation/backend/dao/DBIntegrityService.java (modified) (5 diffs)
• main/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceImlp.java (modified) (9 diffs)
• main/java/eu/dasish/annotation/backend/dao/impl/JdbcAnnotationDao.java (modified) (1 diff)
• main/java/eu/dasish/annotation/backend/rest/AnnotationResource.java (modified) (3 diffs)
• test/java/eu/dasish/annotation/backend/dao/impl/DBIntegrityServiceTest.java (modified) (18 diffs)
• test/java/eu/dasish/annotation/backend/rest/AnnotationResourceTest.java (modified) (4 diffs)
• test/java/eu/dasish/annotation/backend/rest/AnnotationsTest.java (modified) (3 diffs)

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

@@ -133 +133 @@
      * 
      * @param annotationID
-     * @param TargetID
+     * @param targetID
      * @return # updated rows in the joint table "annotations_target_Targets".
      * @throws SQLException 
      * Connects the annotation to its target Target by adding the pair (annotationID, TargetID) to the joint table.
      */ 
-    public int addAnnotationTarget(Number annotationID, Number TargetID) throws SQLException;
+    public int addAnnotationTarget(Number annotationID, Number targetID) throws SQLException;
     
    

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

@@ -143 +143 @@
     Number getTargetInternalIdentifier(UUID externalID); 
 
-    String getTargetURI(Number annotationID);
+    String getTargetURI(Number targetID);
    
-     UUID getTargetExternalIdentifier(Number annotationID);
+     UUID getTargetExternalIdentifier(Number targetID);
+     
+    String getUserURI(Number userID); 
     
     /**
@@ -174 +176 @@
      * 
      * @param annotationID
-     * @return the list of TargetID's for which there is no cached representation
-     */
-    List<Number> getTargetsWithNoCachedRepresentation(Number annotationID);
+     * @return the list of targetURI's for which there is no cached representation
+     */
+    List<String> getTargetsWithNoCachedRepresentation(Number annotationID);
+    
+    List<String> getUsersWithNoInfo(Number annotationID);
     
     /**
@@ -247 +251 @@
      * Sets the "permission" for the "userID" w.r.t. the annotation with "annotationID".
      */
-    public int updateAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission) throws SQLException;
+    public int updateAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission, Number remoteUser) throws SQLException, Exception;
     
    /**
@@ -255 +259 @@
      * @return # of rows updated or added in the table annotations_principals_permissions
      */
-    public int updatePermissions(Number annotationID, UserWithPermissionList permissionList) throws SQLException;
+    public int updatePermissions(Number annotationID, UserWithPermissionList permissionList, Number remoteUser) throws SQLException, Exception;
    
    /**
@@ -299 +303 @@
     Number addUser(User user, String remoteID) throws SQLException;
 
+    int addAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission, Number remoteUser) throws SQLException, Exception;
+    
     /**
      * DELETERS

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

@@ -39 +39 @@
 import eu.dasish.annotation.schema.UserWithPermission;
 import java.io.InputStream;
+import java.lang.Number;
 import java.sql.Blob;
 import java.sql.SQLException;
@@ -97 +98 @@
 
     @Override
-    public UUID getTargetExternalIdentifier(Number annotationID) {
-        return targetDao.getExternalID(annotationID);
-    }
-
-    @Override
-    public String getTargetURI(Number annotationID) {
-        return targetDao.getURIFromInternalID(annotationID);
+    public UUID getTargetExternalIdentifier(Number targetID) {
+        return targetDao.getExternalID(targetID);
+    }
+
+    @Override
+    public String getTargetURI(Number targetID) {
+        return targetDao.getURIFromInternalID(targetID);
+    }
+    
+    @Override
+    public String getUserURI(Number userID) {
+        return userDao.getURIFromInternalID(userID);
     }
 
@@ -130 +136 @@
     @Override
     public Annotation getAnnotation(Number annotationID) throws SQLException {
-        Map<Annotation, Number> annotationOwner = annotationDao.getAnnotationWithoutTargetsAndPermissions(annotationID);
-
-        Annotation[] annotations = new Annotation[1];
-        annotationOwner.keySet().toArray(annotations);
-        Annotation result = annotations[0];
-        result.setOwnerRef(userDao.getURIFromInternalID(annotationOwner.get(result)));
-
-        List<Number> targetIDs = annotationDao.retrieveTargetIDs(annotationID);
-        TargetInfoList sis = new TargetInfoList();
-        for (Number targetID : targetIDs) {
-            Target target = targetDao.getTarget(targetID);
-            TargetInfo targetInfo = new TargetInfo();
-            targetInfo.setLink(target.getLink());
-            targetInfo.setRef(target.getURI());
-            targetInfo.setVersion(target.getVersion());
-            sis.getTargetInfo().add(targetInfo);
-        }
-        result.setTargets(sis);
-
-        result.setPermissions(getPermissionsForAnnotation(annotationID));
-        return result;
+        if (annotationID != null) {
+            Map<Annotation, Number> annotationOwner = annotationDao.getAnnotationWithoutTargetsAndPermissions(annotationID);
+
+            Annotation[] annotations = new Annotation[1];
+            annotationOwner.keySet().toArray(annotations);
+            Annotation result = annotations[0];
+            result.setOwnerRef(userDao.getURIFromInternalID(annotationOwner.get(result)));
+
+            List<Number> targetIDs = annotationDao.retrieveTargetIDs(annotationID);
+            TargetInfoList sis = new TargetInfoList();
+            for (Number targetID : targetIDs) {
+                Target target = targetDao.getTarget(targetID);
+                TargetInfo targetInfo = new TargetInfo();
+                targetInfo.setLink(target.getLink());
+                targetInfo.setRef(target.getURI());
+                targetInfo.setVersion(target.getVersion());
+                sis.getTargetInfo().add(targetInfo);
+            }
+            result.setTargets(sis);
+
+            result.setPermissions(getPermissionsForAnnotation(annotationID));
+            return result;
+        } else {
+            return null;
+        }
     }
 
@@ -157 +167 @@
     @Override
     public UserWithPermissionList getPermissionsForAnnotation(Number annotationID) throws SQLException {
-        List<Map<Number, String>> principalsPermissions = annotationDao.getPermissions(annotationID);
-        UserWithPermissionList result = new UserWithPermissionList();
-        List<UserWithPermission> list = result.getUserWithPermission();
-        for (Map<Number, String> principalPermission : principalsPermissions) {
-
-            Number[] principal = new Number[1];
-            principalPermission.keySet().toArray(principal);
-
-            UserWithPermission userWithPermission = new UserWithPermission();
-            userWithPermission.setRef(userDao.getURIFromInternalID(principal[0]));
-            userWithPermission.setPermission(Permission.fromValue(principalPermission.get(principal[0])));
-
-            list.add(userWithPermission);
-        }
-        return result;
+        if (annotationID != null) {
+            List<Map<Number, String>> principalsPermissions = annotationDao.getPermissions(annotationID);
+            UserWithPermissionList result = new UserWithPermissionList();
+            List<UserWithPermission> list = result.getUserWithPermission();
+            for (Map<Number, String> principalPermission : principalsPermissions) {
+
+                Number[] principal = new Number[1];
+                principalPermission.keySet().toArray(principal);
+
+                UserWithPermission userWithPermission = new UserWithPermission();
+                userWithPermission.setRef(userDao.getURIFromInternalID(principal[0]));
+                userWithPermission.setPermission(Permission.fromValue(principalPermission.get(principal[0])));
+
+                list.add(userWithPermission);
+            }
+            return result;
+        } else {
+            return null;
+        }
+
     }
 
@@ -204 +219 @@
 
     @Override
-    public List<Number> getTargetsWithNoCachedRepresentation(Number annotationID) {
+    public List<String> getTargetsWithNoCachedRepresentation(Number annotationID) {
         if (annotationID == null) {
             return null;
         }
-        List<Number> result = new ArrayList<Number>();
+        List<String> result = new ArrayList<String>();
         List<Number> targetIDs = annotationDao.retrieveTargetIDs(annotationID);
         for (Number targetID : targetIDs) {
             List<Number> versions = targetDao.getCachedRepresentations(targetID);
             if (versions == null) {
-                result.add(targetID);
+                result.add(targetDao.getURIFromInternalID(targetID));
             } else {
                 if (versions.isEmpty()) {
-                    result.add(targetID);
+                    result.add(targetDao.getURIFromInternalID(targetID));
                 }
+
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public List<String> getUsersWithNoInfo(Number annotationID) {
+        if (annotationID == null) {
+            return null;
+        }
+        List<String> result = new ArrayList<String>();
+        List<Map<Number, String>> usersWithPermissions = annotationDao.getPermissions(annotationID);
+        for (Map<Number, String> userWithPermission : usersWithPermissions) {
+            Number[] userID = new Number[1];
+            userWithPermission.keySet().toArray(userID);
+            User user = userDao.getUser(userID[0]);
+
+            if (user.getDisplayName() == null || user.getEMail() == null) {
+                result.add(userDao.getURIFromInternalID(userID[0]));
 
             }
@@ -299 +334 @@
     ///// UPDATERS /////////////////
     @Override
-    public int updateAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission) throws SQLException {
-        return annotationDao.addAnnotationPrincipalPermission(annotationID, userID, permission);
-    }
-
-    @Override
-    public int updatePermissions(Number annotationID, UserWithPermissionList permissionList) throws SQLException {
+    public int updateAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission, Number remoteUser) throws SQLException, Exception {
+        if (annotationDao.getPermission(annotationID, remoteUser) != Permission.OWNER) {
+            throw new Exception("The curent user cannot update the annotation because (s)he is not its owner");
+        }
+        return annotationDao.updateAnnotationPrincipalPermission(annotationID, userID, permission);
+    }
+
+    @Override
+    public int updatePermissions(Number annotationID, UserWithPermissionList permissionList, Number remoteUser) throws SQLException, Exception {
+
+        if (annotationDao.getPermission(annotationID, remoteUser) != Permission.OWNER) {
+            throw new Exception("The curent user cannot update the annotation because (s)he is not its owner");
+        }
+
         List<UserWithPermission> usersWithPermissions = permissionList.getUserWithPermission();
         int result = 0;
@@ -372 +415 @@
             throw new Exception("The current user is not allowed to update this annptation, because (s)he is not its owner");
         }
-        int updatedAnnotations = annotationDao.updateAnnotation(annotation, userID);        
+        int updatedAnnotations = annotationDao.updateAnnotation(annotation, userID);
         Number annotationID = annotationDao.getInternalIDFromURI(annotation.getURI());
         int deletedTargets = annotationDao.deleteAllAnnotationTarget(annotationID);
@@ -388 +431 @@
             return userDao.addUser(user, remoteID);
         }
+    }
+
+    @Override
+    public int addAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission, Number remoteUser) throws SQLException, Exception {
+        if (annotationDao.getPermission(annotationID, remoteUser) != Permission.OWNER) {
+            throw new Exception("The curent user cannot update the annotation because (s)he is not its owner");
+        }
+        return annotationDao.addAnnotationPrincipalPermission(annotationID, userID, permission);
     }
 
@@ -431 +482 @@
         result[0] = annotationDao.deleteAnnotation(annotationID);
         result[3] = 0;
-        if (targetIDs != null)  {
+        if (targetIDs != null) {
             for (Number targetID : targetIDs) {
                 deleteAllCachedRepresentationsOfTarget(targetID);

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

@@ -97 +97 @@
         StringBuilder sql = new StringBuilder("SELECT ");
         sql.append(permission).append(" FROM ").append(permissionsTableName).append(" WHERE ").
-                append(annotation_id).append("  = ").append(annotationID.toString()).
+                append(annotation_id).append("  = ").append(annotationID.toString()).append(" AND ").
                 append(principal_id).append("  = ").append(userID.toString()).append(" LIMIT 1");
         List<Permission> result = getSimpleJdbcTemplate().query(sql.toString(), permissionRowMapper);

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

@@ -21 +21 @@
 import eu.dasish.annotation.backend.dao.DBIntegrityService;
 import eu.dasish.annotation.schema.Annotation;
-import eu.dasish.annotation.schema.AnnotationAction;
-import eu.dasish.annotation.schema.AnnotationActionList;
 import eu.dasish.annotation.schema.AnnotationActionName;
 import eu.dasish.annotation.schema.AnnotationInfoList;
-import eu.dasish.annotation.schema.AnnotationResponseBody;
-import eu.dasish.annotation.schema.AnnotationResponseContent;
+import eu.dasish.annotation.schema.Action;
+import eu.dasish.annotation.schema.ActionList;
 import eu.dasish.annotation.schema.ObjectFactory;
 import eu.dasish.annotation.schema.Permission;
+import eu.dasish.annotation.schema.PermissionActionName;
 import eu.dasish.annotation.schema.UserWithPermissionList;
 import eu.dasish.annotation.schema.ReferenceList;
 import eu.dasish.annotation.schema.ResponseBody;
-import eu.dasish.annotation.schema.Target;
 import java.sql.SQLException;
 import java.sql.Timestamp;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
@@ -167 +166 @@
     public JAXBElement<ResponseBody> createAnnotation(Annotation annotation) throws SQLException, Exception {
         dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
-        return new ObjectFactory().createResponseBody(addAnnotation(annotation));
+
+        //testing mode 
+        //String remoteUser = httpServletRequest.getRemoteUser();
+        // if (remoteUser == null) { throw new Exception();}
+        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
+        UUID userExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
+
+        Number userID = dbIntegrityService.getUserInternalIdentifier(userExternalID);
+        Number annotationID = dbIntegrityService.addUsersAnnotation(userID, annotation);
+        return new ObjectFactory().createResponseBody(makeAnnotationResponseEnvelope(annotationID));
     }
 
@@ -179 +187 @@
         String path = uriInfo.getBaseUri().toString();
         dbIntegrityService.setServiceURI(path);
-        
-        if (!(path+"annotations/"+externalIdentifier).equals(annotation.getURI())) {
+
+        if (!(path + "annotations/" + externalIdentifier).equals(annotation.getURI())) {
             throw new Exception("External annotation id and the annotation id from the request body do not match");
         }
-        return new ObjectFactory().createResponseBody(updateAnnotation(annotation));
+
+        //testing mode 
+        //String remoteUser = httpServletRequest.getRemoteUser();
+        // if (remoteUser == null) { throw new Exception();}
+        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
+        UUID userExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
+
+        Number userID = dbIntegrityService.getUserInternalIdentifier(userExternalID);
+        Number annotationID = dbIntegrityService.updateUsersAnnotation(userID, annotation);
+        return new ObjectFactory().createResponseBody(makeAnnotationResponseEnvelope(annotationID));
     }
 
     @PUT
     @Consumes(MediaType.APPLICATION_XML)
-    @Produces(MediaType.TEXT_XML)
     @Path("{annotationid: " + BackendConstants.regExpIdentifier + "}/permissions/{userid: " + BackendConstants.regExpIdentifier + "}")
-    public int updatePermission(@PathParam("annotationid") String annotationExternalId, @PathParam("userid") String userExternalId, Permission permission) throws SQLException, Exception {
-        dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
+    public String updatePermission(@PathParam("annotationid") String annotationExternalId, @PathParam("userid") String userExternalId, Permission permission) throws SQLException, Exception {
+        dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
+        //String remoteUser = httpServletRequest.getRemoteUser();
+        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
+        //testing mode 
+        UUID remoteUserExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
+        Number remoteUserID = dbIntegrityService.getUserInternalIdentifier(remoteUserExternalID);
         final Number annotationID = dbIntegrityService.getAnnotationInternalIdentifier(UUID.fromString(annotationExternalId));
         final Number userID = dbIntegrityService.getUserInternalIdentifier(UUID.fromString(userExternalId));
         int result;
         if (dbIntegrityService.getPermission(annotationID, userID) != null) {
-            result = dbIntegrityService.updateAnnotationPrincipalPermission(annotationID, userID, permission);
+            result = dbIntegrityService.updateAnnotationPrincipalPermission(annotationID, userID, permission, remoteUserID);
         } else {
-            result = dbIntegrityService.updateAnnotationPrincipalPermission(annotationID, userID, permission);
-        }
+            result = dbIntegrityService.addAnnotationPrincipalPermission(annotationID, userID, permission, remoteUserID);
+        }
+
+        return (result + " rows are updated");
+    }
+
+    @PUT
+    @Consumes(MediaType.APPLICATION_XML)
+    @Produces(MediaType.APPLICATION_XML)
+    @Path("{annotationid: " + BackendConstants.regExpIdentifier + "}/permissions/")
+    public JAXBElement<ResponseBody> updatePermissions(@PathParam("annotationid") String annotationExternalId, UserWithPermissionList permissions) throws SQLException, Exception {
+        dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
+        //String remoteUser = httpServletRequest.getRemoteUser();
+        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
+        //testing mode 
+        UUID remoteUserExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
+        Number remoteUserID = dbIntegrityService.getUserInternalIdentifier(remoteUserExternalID);
+        final Number annotationID = dbIntegrityService.getAnnotationInternalIdentifier(UUID.fromString(annotationExternalId));
+        int updatedRows = dbIntegrityService.updatePermissions(annotationID, permissions, remoteUserID);
+        return new ObjectFactory().createResponseBody(makePermissionResponseEnvelope(annotationID));
+    }
+
+    /////////////////////////////////////////
+   
+    private ResponseBody makeAnnotationResponseEnvelope(Number annotationID) throws SQLException {
+        ResponseBody result = new ResponseBody();
+        result.setPermissions(null);        
+        Annotation annotation = dbIntegrityService.getAnnotation(annotationID);
+        result.setAnnotation(annotation);
+        List<String> targetsNoCached = dbIntegrityService.getTargetsWithNoCachedRepresentation(annotationID);
+        ActionList actionList = new ActionList();
+        result.setActionList(actionList);
+        actionList.getAction().addAll(makeActionList(targetsNoCached,  AnnotationActionName.CREATE_CACHED_REPRESENTATION.value()));        
         return result;
     }
 
-    @PUT
-    @Consumes(MediaType.APPLICATION_XML)
-    @Produces(MediaType.TEXT_XML)
-    @Path("{annotationid: " + BackendConstants.regExpIdentifier + "}/permissions/")
-    public int updatePermissions(@PathParam("annotationid") String annotationExternalId, UserWithPermissionList permissions) throws SQLException, Exception {
-        dbIntegrityService.setServiceURI(uriInfo.getBaseUri().toString());
-
-        final Number annotationID = dbIntegrityService.getAnnotationInternalIdentifier(UUID.fromString(annotationExternalId));
-        return dbIntegrityService.updatePermissions(annotationID, permissions);
-    }
-
-    private ResponseBody makeResponseEnvelope(Number annotationID) throws SQLException {
+    /////////////////////////////////////////
+    private ResponseBody makePermissionResponseEnvelope(Number annotationID) throws SQLException {
         ResponseBody result = new ResponseBody();
-        result.setPermissionResponse(null);
-        AnnotationResponseBody subresult = new AnnotationResponseBody();
-        result.setAnnotationResponse(subresult);
-        AnnotationResponseContent content = new AnnotationResponseContent();
-        subresult.setContent(content);
-
-        if (annotationID != null) {
-            Annotation annotation = dbIntegrityService.getAnnotation(annotationID);
-            content.setAnnotation(annotation);
-            List<Number> targetsNoCached = dbIntegrityService.getTargetsWithNoCachedRepresentation(annotationID);
-            if (targetsNoCached == null) {
-                subresult.setActions(null);
+        result.setAnnotation(null);        
+        UserWithPermissionList permissions = dbIntegrityService.getPermissionsForAnnotation(annotationID);
+        result.setPermissions(permissions);
+        List<String> usersWithNoInfo = dbIntegrityService.getUsersWithNoInfo(annotationID);
+        ActionList actionList = new ActionList();
+        result.setActionList(actionList);
+        actionList.getAction().addAll(makeActionList(usersWithNoInfo, PermissionActionName.PROVIDE_USER_INFO.value()));
+        return result;
+    }
+    
+    private List<Action>  makeActionList(List<String> resourceURIs, String message){
+        if (resourceURIs!=null){
+          if (resourceURIs.isEmpty()) {
+                return (new ArrayList<Action>());
             } else {
-                if (targetsNoCached.isEmpty()) {
-                    subresult.setActions(new AnnotationActionList());
-                } else {
-
-                    AnnotationActionList actions = new AnnotationActionList();
-                    subresult.setActions(actions);
-                    for (Number target : targetsNoCached) {
-                        AnnotationAction action = new AnnotationAction();
-                        actions.getAction().add(action);
-                        action.setAction(AnnotationActionName.CREATE_CACHED_REPRESENTATION);
-                        action.setObject(dbIntegrityService.getTargetURI(target));
-                    }
+                List<Action> result = new ArrayList<Action>();                
+                for (String resourceURI : resourceURIs) {
+                    Action action = new Action();
+                    result.add(action);
+                    action.setMessage(message);
+                    action.setObject(resourceURI);
                 }
-            }
-
-        } else {
-            content.setAnnotation(null);
-        }
-        return result;
-    }
-
-    private ResponseBody addAnnotation(Annotation annotation) throws SQLException, Exception {
-        // Where the map remoteUSer-->externalID is saved and how to get it?
-        String remoteUser = httpServletRequest.getRemoteUser();
-        // if (remoteUser == null) { throw new Exception();}
-        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
-        //testing mode 
-        UUID userExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
-        Number userID = dbIntegrityService.getUserInternalIdentifier(userExternalID);
-        Number annotationID= dbIntegrityService.addUsersAnnotation(userID, annotation);
-        return makeResponseEnvelope(annotationID);
-    }
-    
-    
-    private ResponseBody updateAnnotation(Annotation annotation) throws SQLException, Exception {
-        // Where the map remoteUSer-->externalID is saved and how to get it?
-        String remoteUser = httpServletRequest.getRemoteUser();
-        // if (remoteUser == null) { throw new Exception();}
-        //UUID externalID = getExternalIDforREmoteUSer(remoteUser);
-        //testing mode 
-        UUID userExternalID = UUID.fromString("00000000-0000-0000-0000-0000000000111");
-        Number userID = dbIntegrityService.getUserInternalIdentifier(userExternalID);
-        dbIntegrityService.updateUsersAnnotation(userID, annotation);
-        Number annotationID = dbIntegrityService.getAnnotationInternalIdentifierFromURI(annotation.getURI());
-        return makeResponseEnvelope(annotationID);
+                return result;
+            }  
+        }
+        else {
+            return null;
+        }
     }
 }

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

@@ -76 +76 @@
     private CachedRepresentationDao cachedRepresentationDao;    
     @Autowired
-    private TargetDao TargetDao;
+    private TargetDao targetDao;
     @Autowired
     private AnnotationDao annotationDao;
@@ -233 +233 @@
                 will(returnValue(mockTargetIDs));
 
-                oneOf(TargetDao).getTarget(1);
+                oneOf(targetDao).getTarget(1);
                 will(returnValue(mockTargetOne));
 
-                oneOf(TargetDao).getTarget(2);
+                oneOf(targetDao).getTarget(2);
                 will(returnValue(mockTargetTwo));
 
@@ -310 +310 @@
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(TargetDao).getTargetsReferringTo(word);
+                oneOf(targetDao).getTargetsReferringTo(word);
                 will(returnValue(mockTargetIDs));
 
@@ -344 +344 @@
                 will(returnValue(TargetIDs));
 
-                oneOf(TargetDao).getURIFromInternalID(1);
+                oneOf(targetDao).getURIFromInternalID(1);
                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets+TestBackendConstants._TEST_Target_1_EXT_ID));
 
-                oneOf(TargetDao).getURIFromInternalID(2);
+                oneOf(targetDao).getURIFromInternalID(2);
                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets+TestBackendConstants._TEST_Target_2_EXT_ID));
 
@@ -410 +410 @@
             {
                 // getFilteredAnnotationIds
-                oneOf(TargetDao).getTargetsReferringTo(word);
+                oneOf(targetDao).getTargetsReferringTo(word);
                 will(returnValue(mockTargetIDs));
                 
@@ -432 +432 @@
                 will(returnValue(TargetIDs));
                 
-                oneOf(TargetDao).getURIFromInternalID(1);
+                oneOf(targetDao).getURIFromInternalID(1);
                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets +TestBackendConstants._TEST_Target_1_EXT_ID));
                 
-                oneOf(TargetDao).getURIFromInternalID(2);
+                oneOf(targetDao).getURIFromInternalID(2);
                 will(returnValue(TestBackendConstants._TEST_SERVLET_URI_Targets +TestBackendConstants._TEST_Target_2_EXT_ID));
                 ////
@@ -458 +458 @@
     }
     
-    @Test
-    
+    @Test    
     public void testGetTargetsWithNoCachedRepresentation(){
         System.out.println("test getTargetsWithNoCachedRepresentation");
@@ -478 +477 @@
                 will(returnValue(TargetIDs));
 
-                oneOf(TargetDao).getCachedRepresentations(5);
+                oneOf(targetDao).getCachedRepresentations(5);
                 will(returnValue(cachedIDs5));
                 
-                oneOf(TargetDao).getCachedRepresentations(7);
+                oneOf(targetDao).getCachedRepresentations(7);
                 will(returnValue(cachedIDs7));
                 
-            }
-        });
-        
-        List<Number> result = dbIntegrityService.getTargetsWithNoCachedRepresentation(annotationID);
+                oneOf(targetDao).getURIFromInternalID(7);
+                will(returnValue("00000000-0000-0000-0000-000000000037"));
+                
+            }
+        });
+        
+        List<String> result = dbIntegrityService.getTargetsWithNoCachedRepresentation(annotationID);
         assertEquals(1, result.size());
-        assertEquals(7, result.get(0)); // Target number 7 has no cached
+        assertEquals("00000000-0000-0000-0000-000000000037", result.get(0)); // Target number 7 has no cached
     }
     
@@ -497 +499 @@
      * Test of addCachedForVersion method, of class DBIntegrityServiceImlp.
      */
-    @Test
-    
+    @Test    
     public void testAddCachedForVersion() throws SerialException, SQLException {
         System.out.println("addCachedForVersion");
@@ -525 +526 @@
                 will(returnValue(newCachedID));
 
-                one(TargetDao).addTargetCachedRepresentation(versionID, newCachedID);
+                one(targetDao).addTargetCachedRepresentation(versionID, newCachedID);
                 will(returnValue(1));
 
@@ -582 +583 @@
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(TargetDao).getInternalIDFromURI(mockTargetListOne.get(0).getRef());
+                oneOf(targetDao).getInternalIDFromURI(mockTargetListOne.get(0).getRef());
                 will(returnValue(1));
 
@@ -626 +627 @@
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(TargetDao).getInternalIDFromURI(mockTargetListTwo.get(0).getRef());
+                oneOf(targetDao).getInternalIDFromURI(mockTargetListTwo.get(0).getRef());
                 will(returnValue(null));
 
-                oneOf(TargetDao).addTarget(with(aNonNull(Target.class)));
+                oneOf(targetDao).addTarget(with(aNonNull(Target.class)));
                 will(returnValue(8)); //# the next new number is 8, we have already 7 Targets
 
-                oneOf(TargetDao).stringURItoExternalID(mockTargetListTwo.get(0).getRef());
+                oneOf(targetDao).stringURItoExternalID(mockTargetListTwo.get(0).getRef());
                 will(returnValue(tempTargetID));
 
-                oneOf(TargetDao).getExternalID(8);
+                oneOf(targetDao).getExternalID(8);
                 will(returnValue(mockNewTargetUUID));
 
@@ -667 +668 @@
 
                 //  expectations for addTargetsForannotation
-                oneOf(TargetDao).getInternalIDFromURI(with(aNonNull(String.class)));
+                oneOf(targetDao).getInternalIDFromURI(with(aNonNull(String.class)));
                 will(returnValue(1));
 
@@ -756 +757 @@
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(TargetDao).deleteTargetCachedRepresentation(5, 7);
+                oneOf(targetDao).deleteTargetCachedRepresentation(5, 7);
                 will(returnValue(1));
 
@@ -782 +783 @@
         mockeryDao.checking(new Expectations() {
             {
-                oneOf(TargetDao).getCachedRepresentations(1);
+                oneOf(targetDao).getCachedRepresentations(1);
                 will(returnValue(cachedList));
                 
-                oneOf(TargetDao).deleteTargetCachedRepresentation(1, 1);
+                oneOf(targetDao).deleteTargetCachedRepresentation(1, 1);
                 will(returnValue(1));
                 
@@ -791 +792 @@
                 will(returnValue(1));
                 
-                oneOf(TargetDao).deleteTargetCachedRepresentation(1, 2);
+                oneOf(targetDao).deleteTargetCachedRepresentation(1, 2);
                 will(returnValue(1));
                 
@@ -837 +838 @@
                 will(returnValue(1));
                 
-                oneOf(TargetDao).getCachedRepresentations(2);
+                oneOf(targetDao).getCachedRepresentations(2);
                 will(returnValue(mockCachedIDs));
                 
-                oneOf(TargetDao).deleteTargetCachedRepresentation(2, 3);
+                oneOf(targetDao).deleteTargetCachedRepresentation(2, 3);
                 will(returnValue(1));
                 
@@ -846 +847 @@
                 will(returnValue(1));
                 
-                oneOf(TargetDao).deleteTarget(2);
+                oneOf(targetDao).deleteTarget(2);
                 will(returnValue(1));
 

DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/rest/AnnotationResourceTest.java

@@ -212 +212 @@
         TargetInfo.setVersion("vandaag");
         
-        final List<Number> Targets = new ArrayList<Number>();
-        Targets.add(6);
+        final List<String> targets = new ArrayList<String>();
+        targets.add("http://localhost:8080/annotator-backend/api/targets/00000000-0000-0000-0000-000000000036");
         
         final Annotation addedAnnotation = (new ObjectFactory()).createAnnotation(annotationToAdd).getValue();
@@ -247 +247 @@
                 
                 oneOf(daoDispatcher).getTargetsWithNoCachedRepresentation(newAnnotationID);
-                will(returnValue(Targets));
-                
-                oneOf(daoDispatcher).getTargetURI(6);
-                will(returnValue("http://localhost:8080/annotator-backend/api/targets/00000000-0000-0000-0000-000000000036"));
-            }
+                will(returnValue(targets));
+                
+          }
         });
         
@@ -262 +260 @@
         
         JAXBElement<ResponseBody> result = annotationResource.createAnnotation(annotationToAdd);
-        Annotation newAnnotation = result.getValue().getAnnotationResponse().getContent().getAnnotation();
-        AnnotationActionName actionName = result.getValue().getAnnotationResponse().getActions().getAction().get(0).getAction();
+        Annotation newAnnotation = result.getValue().getAnnotation();
+        String actionName = result.getValue().getActionList().getAction().get(0).getMessage();
         assertEquals(addedAnnotation.getOwnerRef(), newAnnotation.getOwnerRef());
         assertEquals(addedAnnotation.getURI(), newAnnotation.getURI());
@@ -270 +268 @@
         assertEquals(addedAnnotation.getTimeStamp(), newAnnotation.getTimeStamp());
         assertEquals(addedAnnotation.getBody(), newAnnotation.getBody());
-        assertEquals(AnnotationActionName.CREATE_CACHED_REPRESENTATION, actionName);
+        assertEquals(AnnotationActionName.CREATE_CACHED_REPRESENTATION.value(), actionName);
     }
 }

DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/test/java/eu/dasish/annotation/backend/rest/AnnotationsTest.java

@@ -23 +23 @@
 import eu.dasish.annotation.backend.TestBackendConstants;
 import eu.dasish.annotation.schema.Annotation;
-import eu.dasish.annotation.schema.AnnotationResponseBody;
-import eu.dasish.annotation.schema.AnnotationResponseContent;
 import eu.dasish.annotation.schema.ObjectFactory;
 import eu.dasish.annotation.schema.ResponseBody;
@@ -166 +164 @@
         ResponseBody responseBody = new ResponseBody();
         final JAXBElement<ResponseBody> jaxbElement = (new ObjectFactory()).createResponseBody(responseBody);
-        responseBody.setPermissionResponse(null);
-        AnnotationResponseBody arb =new AnnotationResponseBody();
-        responseBody.setAnnotationResponse(arb);
-        arb.setActions(null);
-        AnnotationResponseContent content = new AnnotationResponseContent();
-        arb.setContent(content);        
+        responseBody.setPermissions(null);
         final Annotation addedAnnotation = new Annotation();
+        responseBody.setAnnotation(addedAnnotation);
+        responseBody.setActionList(null);
+        
         TargetInfoList TargetInfoList = new TargetInfoList();
         addedAnnotation.setTargets(TargetInfoList);
@@ -220 +216 @@
         
         ResponseBody entity = response.getEntity(ResponseBody.class); 
-        Annotation entityA = entity.getAnnotationResponse().getContent().getAnnotation();
+        Annotation entityA = entity.getAnnotation();
         assertEquals(addedAnnotation.getBody(), entityA.getBody());
         assertEquals(addedAnnotation.getHeadline(), entityA.getHeadline());