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

/*
 * Copyright (C) 2013 DASISH
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package eu.dasish.annotation.backend.dao.impl;

import eu.dasish.annotation.backend.Resource;
import eu.dasish.annotation.backend.Helpers;
import eu.dasish.annotation.backend.dao.AnnotationDao;
import eu.dasish.annotation.backend.dao.CachedRepresentationDao;
import eu.dasish.annotation.backend.dao.DBIntegrityService;
import eu.dasish.annotation.backend.dao.NotebookDao;
import eu.dasish.annotation.backend.dao.ResourceDao;
import eu.dasish.annotation.backend.dao.TargetDao;
import eu.dasish.annotation.backend.dao.UserDao;
import eu.dasish.annotation.backend.rest.AnnotationResource;
import eu.dasish.annotation.schema.Action;
import eu.dasish.annotation.schema.ActionList;
import eu.dasish.annotation.schema.Annotation;
import eu.dasish.annotation.schema.AnnotationActionName;
import eu.dasish.annotation.schema.AnnotationBody;
import eu.dasish.annotation.schema.AnnotationInfo;
import eu.dasish.annotation.schema.AnnotationInfoList;
import eu.dasish.annotation.schema.CachedRepresentationFragment;
import eu.dasish.annotation.schema.CachedRepresentationFragmentList;
import eu.dasish.annotation.schema.CachedRepresentationInfo;
import eu.dasish.annotation.schema.Notebook;
import eu.dasish.annotation.schema.NotebookInfo;
import eu.dasish.annotation.schema.NotebookInfoList;
import eu.dasish.annotation.schema.TargetInfoList;
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 eu.dasish.annotation.schema.TargetInfo;
import eu.dasish.annotation.schema.User;
import eu.dasish.annotation.schema.UserWithPermission;
import java.io.InputStream;
import java.lang.Number;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.lang.reflect.Field;
import org.springframework.beans.factory.annotation.Autowired;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author olhsha
 */
public class DBIntegrityServiceImlp implements DBIntegrityService {

    @Autowired
    UserDao userDao;
    @Autowired
    CachedRepresentationDao cachedRepresentationDao;
    @Autowired
    TargetDao targetDao;
    @Autowired
    AnnotationDao annotationDao;
    @Autowired
    NotebookDao notebookDao;
    private String remoteUser=null;
    
    
    final static protected String admin = "admin";
    private static final Logger logger = LoggerFactory.getLogger(DBIntegrityServiceImlp.class);

    //////////////////////////////////
    private ResourceDao getDao(Resource resource) {
        switch (resource) {
            case PRINCIPAL:
                return userDao;
            case ANNOTATION:
                return annotationDao;
            case TARGET:
                return targetDao;
            case CACHED_REPRESENTATION:
                return cachedRepresentationDao;
            case NOTEBOOK:
                return notebookDao;
            default:
                return null;
        }
    }
    
    public String getRemoteUser(){
        return remoteUser;
    }
    
    public void setRemoteUser(String currentUser){
        remoteUser = currentUser;
    }
    

    @Override
    public void setServiceURI(String serviceURI) {
        userDao.setServiceURI(serviceURI + "users/");
        cachedRepresentationDao.setServiceURI(serviceURI + "cached/");
        targetDao.setServiceURI(serviceURI + "targets/");
        annotationDao.setServiceURI(serviceURI + "annotations/");
        notebookDao.setServiceURI(serviceURI + "notebooks/");
    }

    ///////////// GETTERS //////////////////////////
    @Override
    public Number getResourceInternalIdentifier(UUID externalID, Resource resource) {
        return this.getDao(resource).getInternalID(externalID);
    }

    @Override
    public Number getResourceInternalIdentifierFromURI(String uri, Resource resource) {
        return this.getDao(resource).getInternalIDFromURI(uri);
    }

    @Override
    public UUID getResourceExternalIdentifier(Number resourceID, Resource resource) {
        return this.getDao(resource).getExternalID(resourceID);
    }

    @Override
    public String getResourceURI(Number resourceID, Resource resource) {
        return this.getDao(resource).getURIFromInternalID(resourceID);
    }

    @Override
    public Annotation getAnnotation(Number annotationID) {
        if (annotationID != null) {
            Annotation result = annotationDao.getAnnotationWithoutTargetsAndPermissions(annotationID);
            result.setOwnerRef(userDao.getURIFromInternalID(annotationDao.getOwner(annotationID)));
            List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
            TargetInfoList sis = new TargetInfoList();
            for (Number targetID : targetIDs) {
                TargetInfo targetInfo = getTargetInfoFromTarget(targetDao.getTarget(targetID));
                sis.getTargetInfo().add(targetInfo);
            }
            result.setTargets(sis);

            result.setPermissions(this.getPermissions(annotationID, Resource.ANNOTATION));
            return result;
        } else {
            return null;
        }
    }

    @Override
    public Number getAnnotationOwnerID(Number annotationID) {
        return annotationDao.getOwner(annotationID);
    }
    
    @Override
    public User getAnnotationOwner(Number annotationID) {
       return userDao.getUser(annotationDao.getOwner(annotationID)); 
    }

    ///////////////////////////////////////////////////
    // TODO UNIT tests
    @Override
    public UserWithPermissionList getPermissions(Number resourceID, Resource resource) {
        if (resourceID != null) {
            List<Map<Number, String>> principalsPermissions = this.getDao(resource).getPermissions(resourceID);
            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;

        }
        return null;
    }

////////////////////////////////////////////////////////////////////////
    @Override
    public List<Number> getFilteredAnnotationIDs(UUID ownerId, String link, String text, Number inloggedUserID, String access, String namespace, String after, String before) {

        Number ownerID = (ownerId != null) ? userDao.getInternalID(ownerId) : null;
        if (ownerID != null) {
            if ("owner".equals(access) && !inloggedUserID.equals(ownerID)) {
                logger.info("The inlogged user cannot be the owner of the annotations owned by " + ownerId.toString());
                return null;
            }
        }

        //filtering on tables "target" and "annotations_targets"
        List<Number> annotationIDsForTargets = null;
        if (link != null) {
            List<Number> targetIDs = targetDao.getTargetsReferringTo(link);
            annotationIDsForTargets = annotationDao.getAnnotationIDsForTargets(targetIDs);
            if (annotationIDsForTargets == null) {
                logger.info("There are no annotations for the targets referring to " + link + ".");
                return null;
            }
        }

        // filtering in the table "annotation"
        if (ownerID == null && "owner".equals(access)) {
            ownerID = inloggedUserID;
        }
        List<Number> annotationIDs = annotationDao.getFilteredAnnotationIDs(ownerID, text, namespace, after, before);
        if (annotationIDs != null) {
            if (annotationIDsForTargets != null) {
                annotationIDs.retainAll(annotationIDsForTargets);
            } else {
                // nothing to filter on link == null
            }
        } else {
            logger.info("There are no annotations for the given filters on the annotation table.");
            return null;
        }

        // filtering on table "annotations_principals_permissions"
        if ("reader".equals(access) || "writer".equals(access)) {
            // owner != inloggedUser
            List<Number> annotationIDsPermission = annotationDao.getAnnotationIDsForUserWithPermission(inloggedUserID, access);
            if (annotationIDsPermission != null) {
                annotationIDs.retainAll(annotationIDsPermission);
            } else {
                logger.info("There are no annotations for which the inlogged user has access " + access);
                return null;
            }
        } else {
            // inloggedUser == owner
        }
        return annotationIDs;
    }

    @Override
    public ReferenceList getAnnotationTargets(Number annotationID) {
        ReferenceList result = new ReferenceList();
        List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
        for (Number targetID : targetIDs) {
            result.getRef().add(targetDao.getURIFromInternalID(targetID));
        }
        return result;
    }

    @Override
    public List<String> getTargetsWithNoCachedRepresentation(Number annotationID) {
        if (annotationID == null) {
            return null;
        }
        List<String> result = new ArrayList<String>();
        List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
        for (Number targetID : targetIDs) {
            List<Number> versions = cachedRepresentationDao.getCachedRepresentationsForTarget(targetID);
            if (versions == null) {
                result.add(targetDao.getURIFromInternalID(targetID));
            } else {
                if (versions.isEmpty()) {
                    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.getDisplayName().trim().isEmpty() || user.getEMail() == null || user.getEMail().trim().isEmpty()) {
                result.add(userDao.getURIFromInternalID(userID[0]));

            }
        }
        return result;
    }

    @Override
    public AnnotationInfoList getFilteredAnnotationInfos(UUID ownerId, String word, String text, Number inloggedUserID, String access, String namespace, String after, String before) {
        List<Number> annotationIDs = this.getFilteredAnnotationIDs(ownerId, word, text, inloggedUserID, access, namespace, after, before);
        if (annotationIDs != null) {
            AnnotationInfoList result = new AnnotationInfoList();
            for (Number annotationID : annotationIDs) {
                AnnotationInfo annotationInfo = annotationDao.getAnnotationInfoWithoutTargets(annotationID);
                annotationInfo.setTargets(this.getAnnotationTargets(annotationID));
                annotationInfo.setOwnerRef(userDao.getURIFromInternalID(annotationDao.getOwner(annotationID)));
                result.getAnnotationInfo().add(annotationInfo);
            }

            return result;
        } else {
            return null;
        }
    }

    @Override
    public AnnotationInfoList getAllAnnotationInfos() {
        List<Number> annotationIDs = annotationDao.getAllAnnotationIDs();
        if (annotationIDs != null) {
            AnnotationInfoList result = new AnnotationInfoList();
            for (Number annotationID : annotationIDs) {
                Number ownerID = annotationDao.getOwner(annotationID);
                ReferenceList targets = getAnnotationTargets(annotationID);
                AnnotationInfo annotationInfo = annotationDao.getAnnotationInfoWithoutTargets(annotationID);
                annotationInfo.setTargets(targets);
                if (ownerID != null) {
                    annotationInfo.setOwnerRef(userDao.getURIFromInternalID(ownerID));
                } else {
                    annotationInfo.setOwnerRef("ACHTUNG: This annotation does not have an owner in the DB!!!!");
                }
                result.getAnnotationInfo().add(annotationInfo);
            }

            return result;
        } else {
            return null;
        }
    }

    // TODO unit test
    @Override
    public Target getTarget(Number internalID) {
        Target result = targetDao.getTarget(internalID);
        result.setSiblingTargets(getTargetsForTheSameLinkAs(internalID));
        Map<Number, String> cachedIDsFragments = targetDao.getCachedRepresentationFragmentPairs(internalID);
        CachedRepresentationFragmentList cachedRepresentationFragmentList = new CachedRepresentationFragmentList();
        for (Number key : cachedIDsFragments.keySet()) {
            CachedRepresentationFragment cachedRepresentationFragment = new CachedRepresentationFragment();
            cachedRepresentationFragment.setRef(cachedRepresentationDao.getURIFromInternalID(key));
            cachedRepresentationFragment.setFragmentString(cachedIDsFragments.get(key));
            cachedRepresentationFragmentList.getCached().add(cachedRepresentationFragment);
        }
        result.setCachedRepresentatinons(cachedRepresentationFragmentList);
        return result;
    }

    // TODO unit test
    @Override
    public CachedRepresentationInfo getCachedRepresentationInfo(Number internalID) {
        return cachedRepresentationDao.getCachedRepresentationInfo(internalID);
    }

    //TODO unit test
    @Override
    public InputStream getCachedRepresentationBlob(Number cachedID) {
        return cachedRepresentationDao.getCachedRepresentationBlob(cachedID);
    }

    @Override
    public ReferenceList getTargetsForTheSameLinkAs(Number targetID) {
        List<Number> targetIDs = targetDao.getTargetsForLink(targetDao.getLink(targetID));
        ReferenceList referenceList = new ReferenceList();
        for (Number siblingID : targetIDs) {
            referenceList.getRef().add(targetDao.externalIDtoURI(targetDao.getExternalID(siblingID).toString()));
        }
        return referenceList;
    }

    @Override
    public User getUser(Number userID) {
        return userDao.getUser(userID);
    }

    @Override
    public User getUserByInfo(String eMail) {
        return userDao.getUserByInfo(eMail);
    }

    @Override
    public String getUserRemoteID(Number internalID) {
        return userDao.getRemoteID(internalID);
    }

    @Override
    public Permission getPermission(Number annotationID, Number userID) {
        return annotationDao.getPermission(annotationID, userID);
    }

    @Override
    public Number getUserInternalIDFromRemoteID(String remoteID) {
        return userDao.getUserInternalIDFromRemoteID(remoteID);
    }

    @Override
    public String getTypeOfUserAccount(Number userID) {
        return userDao.getTypeOfUserAccount(userID);
    }
    
    @Override
    public User getDataBaseAdmin(){
        return userDao.getUser(userDao.getDBAdminID());
    }
    

    @Override
    public boolean canRead(Number userID, Number annotationID) {
        if (userID.equals(annotationDao.getOwner(annotationID)) || userDao.getTypeOfUserAccount(userID).equals(admin)) {
            return true;
        }

        final Permission permission = annotationDao.getPermission(annotationID, userID);
        if (permission != null) {
            return (permission.value().equals(Permission.WRITER.value()) || permission.value().equals(Permission.READER.value()));
        } else {
            return false;
        }
    }

    @Override
    public boolean canWrite(Number userID, Number annotationID) {
        if (userID.equals(annotationDao.getOwner(annotationID)) || userDao.getTypeOfUserAccount(userID).equals(admin)) {
            return true;
        }
        final Permission permission = annotationDao.getPermission(annotationID, userID);
        if (permission != null) {
            return (permission.value().equals(Permission.WRITER.value()));
        } else {
            return false;
        }
    }
    
    ////// noetbooks ///////

    @Override
    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;
    }

    @Override
    public boolean hasAccess(Number notebookID, Number principalID, Permission permission) {
        List<Number> notebookIDs = notebookDao.getNotebookIDs(principalID, permission);
        if (notebookIDs == null) {
            return false;
        }
        return notebookIDs.contains(notebookID);
    }

    @Override
    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;
    }

    @Override
    public ReferenceList getPrincipals(Number notebookID, String permission) {
        ReferenceList result = new ReferenceList();
        List<Number> principalIDs = userDao.getPrincipalIDsWithPermissionForNotebook(notebookID, Permission.fromValue(permission));
        for (Number principalID : principalIDs) {
            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 = annotationDao.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 = userDao.getPrincipalIDsWithPermissionForNotebook(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;
    }

    @Override
    public Number getNotebookOwner(Number notebookID) {
        return notebookDao.getOwner(notebookID);
    }

    /////////////////////////////////////////////////////////////
    @Override
    public ReferenceList getAnnotationsForNotebook(Number notebookID, int startAnnotation, int maximumAnnotations, String orderedBy, boolean desc) {
        List<Number> annotationIDs = annotationDao.getAnnotations(notebookID);

        if (startAnnotation < -1) {
            logger.info("Variable's startAnnotation value " + startAnnotation + " is invalid. I will return null.");
            return null;
        }

        if (maximumAnnotations < -1) {
            logger.info("Variable's maximumAnnotations value " + maximumAnnotations + " is invalid. I will return null.");
            return null;
        }

        int offset = (startAnnotation > 0) ? startAnnotation - 1 : 0;
        String direction = desc ? "DESC" : "ASC";
        List<Number> selectedAnnotIDs = annotationDao.sublistOrderedAnnotationIDs(annotationIDs, offset, maximumAnnotations, orderedBy, direction);
        ReferenceList references = new ReferenceList();
        for (Number annotationID : selectedAnnotIDs) {
            references.getRef().add(annotationDao.getURIFromInternalID(annotationID));
        }
        return references;
    }

    ///// UPDATERS /////////////////
    @Override
    public boolean updateAccount(UUID userExternalID, String account) {
        return userDao.updateAccount(userExternalID, account);
    }

    @Override
    public int updateAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission) {
        if (permission != null) {
            return annotationDao.updateAnnotationPrincipalPermission(annotationID, userID, permission);
        } else {
            return annotationDao.deleteAnnotationPrincipalPermission(annotationID, userID);
        }
    }

    @Override
    public int updatePermissions(Number annotationID, UserWithPermissionList permissionList) {

        List<UserWithPermission> usersWithPermissions = permissionList.getUserWithPermission();
        int result = 0;
        for (UserWithPermission userWithPermission : usersWithPermissions) {
            Number userID = userDao.getInternalID(UUID.fromString(userDao.stringURItoExternalID(userWithPermission.getRef())));
            if (userID != null) {
                Permission permission = userWithPermission.getPermission();
                Permission currentPermission = annotationDao.getPermission(annotationID, userID);
                if (currentPermission != null) {
                    if (!permission.value().equals(currentPermission.value())) {
                        result = result + annotationDao.updateAnnotationPrincipalPermission(annotationID, userID, permission);
                    }
                } else {
                    result = result + annotationDao.addAnnotationPrincipalPermission(annotationID, userID, permission);
                }
            }
        }

        return result;
    }

    // TODO: optimize (not chnaged targets should not be deleted)
    // TODO: unit test
    @Override
    public int updateAnnotation(Annotation annotation) {
        int updatedAnnotations = annotationDao.updateAnnotation(annotation, userDao.getInternalIDFromURI(annotation.getOwnerRef()));
        Number annotationID = annotationDao.getInternalIDFromURI(annotation.getURI());
        int deletedTargets = annotationDao.deleteAllAnnotationTarget(annotationID);
        int deletedPrinsipalsPermissions = annotationDao.deleteAnnotationPrincipalPermissions(annotationID);
        int addedTargets = addTargets(annotation, annotationID);
        int addedPrincipalsPermissions = addPrincipalsPermissions(annotation.getPermissions().getUserWithPermission(), annotationID);
        return updatedAnnotations;
    }

    // TODO: unit test
    @Override
    public int updateAnnotationBody(Number internalID, AnnotationBody annotationBody) {
        String[] body = annotationDao.retrieveBodyComponents(annotationBody);
        return annotationDao.updateAnnotationBody(internalID, body[0], body[1], annotationBody.getXmlBody() != null);
    }

    @Override
    public Number updateUser(User user) {
        return userDao.updateUser(user);
    }
    /// notebooks ///

    @Override
    public boolean updateNotebookMetadata(Number notebookID, NotebookInfo upToDateNotebookInfo) {
        Number ownerID = userDao.getInternalIDFromURI(upToDateNotebookInfo.getOwnerRef());
        return notebookDao.updateNotebookMetadata(notebookID, upToDateNotebookInfo.getTitle(), ownerID);
    }

    @Override
    public boolean addAnnotationToNotebook(Number notebookID, Number annotationID) {
        return notebookDao.addAnnotationToNotebook(notebookID, annotationID);
    }

    /////////////// ADDERS  /////////////////////////////////
    @Override
    public Number[] addCachedForTarget(Number targetID, String fragmentDescriptor, CachedRepresentationInfo cachedInfo, InputStream cachedBlob) {
        Number[] result = new Number[2];
        result[1] = cachedRepresentationDao.getInternalIDFromURI(cachedInfo.getURI());
        if (result[1] == null) {
            result[1] = cachedRepresentationDao.addCachedRepresentation(cachedInfo, cachedBlob);
        }
        result[0] = targetDao.addTargetCachedRepresentation(targetID, result[1], fragmentDescriptor);
        return result;

    }

    // TODo: mapping uri to external ID
    @Override
    public Map<String, String> addTargetsForAnnotation(Number annotationID, List<TargetInfo> targets) {
        Map<String, String> result = new HashMap<String, String>();
        Number targetIDRunner;
        for (TargetInfo targetInfo : targets) {
            targetIDRunner = targetDao.getInternalIDFromURI(targetInfo.getRef());
            if (targetIDRunner != null) {
                int affectedRows = annotationDao.addAnnotationTarget(annotationID, targetIDRunner);
            } else {
                Target newTarget = createFreshTarget(targetInfo);
                Number targetID = targetDao.addTarget(newTarget);
                String targetTemporaryID = targetDao.stringURItoExternalID(targetInfo.getRef());
                result.put(targetTemporaryID, targetDao.getExternalID(targetID).toString());
                int affectedRows = annotationDao.addAnnotationTarget(annotationID, targetID);
            }
        }
        return result;
    }

    @Override
    public Number addUsersAnnotation(Number ownerID, Annotation annotation) {
        Number annotationID = annotationDao.addAnnotation(annotation, ownerID);
        int affectedAnnotRows = addTargets(annotation, annotationID);
        if (annotation.getPermissions() != null) {
            if (annotation.getPermissions().getUserWithPermission() != null) {
                int addedPrincipalsPermissions = this.addPrincipalsPermissions(annotation.getPermissions().getUserWithPermission(), annotationID);
            }
        }
        return annotationID;
    }

    @Override
    public Number addUser(User user, String remoteID) {
        if (userDao.userExists(user)) {
            return null;
        } else {
            return userDao.addUser(user, remoteID);
        }
    }

    @Override
    public int addAnnotationPrincipalPermission(Number annotationID, Number userID, Permission permission) {
        return annotationDao.addAnnotationPrincipalPermission(annotationID, userID, permission);
    }

    //////////// notebooks //////
    @Override
    public Number createNotebook(Notebook notebook, Number ownerID) {
        Number notebookID = notebookDao.createNotebookWithoutPermissionsAndAnnotations(notebook, ownerID);
        boolean updateOwner = notebookDao.setOwner(notebookID, ownerID);
        List<UserWithPermission> permissions = notebook.getPermissions().getUserWithPermission();
        for (UserWithPermission principalPermission : permissions) {
            Number principalID = userDao.getInternalIDFromURI(principalPermission.getRef());
            Permission permission = principalPermission.getPermission();
            boolean updatePermissions = notebookDao.addPermissionToNotebook(notebookID, principalID, permission);
        }
        return notebookID;
    }

    @Override
    public boolean createAnnotationInNotebook(Number notebookID, Annotation annotation, Number ownerID) {
        Number newAnnotationID = this.addUsersAnnotation(ownerID, annotation);
        return notebookDao.addAnnotationToNotebook(notebookID, newAnnotationID);
    }

    ////////////// DELETERS //////////////////
    
   
    
    
    @Override
    public int deleteUser(Number userID) {
        return userDao.deleteUser(userID);
    }

    
    @Override
    public int deleteUserSafe(Number userID) {
        return userDao.deleteUserSafe(userID);
    }

    @Override
    public int deleteCachedRepresentation(Number internalID) {
        
        if (internalID == null) {
            logger.debug("Cached's internalID is null");
            return 0;
        }
        
        if (targetDao.cachedIsInUse(internalID)) {
            logger.debug("Cached Repr. is in use, and cannot be deleted.");
            return 0;
        }

        return cachedRepresentationDao.deleteCachedRepresentation(internalID);
    };
    
    
    @Override
    public int[] deleteCachedRepresentationOfTarget(Number versionID, Number cachedID) {
        int[] result = new int[2];
        result[0] = targetDao.deleteTargetCachedRepresentation(versionID, cachedID);
        if (result[0] > 0) {
            result[1] = cachedRepresentationDao.deleteCachedRepresentation(cachedID);
        } else {
            result[1] = 0;

        }
        return result;
    }

    @Override
    public int[] deleteAllCachedRepresentationsOfTarget(Number targetID) {
        int[] result = new int[2];
        result[0] = 0;
        result[1] = 0;
        List<Number> cachedIDs = cachedRepresentationDao.getCachedRepresentationsForTarget(targetID);
        for (Number cachedID : cachedIDs) {
            int[] currentResult = this.deleteCachedRepresentationOfTarget(targetID, cachedID);
            result[0] = result[0] + currentResult[0];
            result[1] = result[1] + currentResult[1];
        }
        return result;
    }

    @Override
    public int[] deleteAnnotation(Number annotationID) {
        int[] result = new int[5];
        result[1] = annotationDao.deleteAnnotationPrincipalPermissions(annotationID);
        List<Number> targetIDs = targetDao.retrieveTargetIDs(annotationID);
        result[2] = annotationDao.deleteAllAnnotationTarget(annotationID);
        result[3] = 0;
        if (targetIDs != null) {
            for (Number targetID : targetIDs) {
                this.deleteAllCachedRepresentationsOfTarget(targetID);
                result[3] = result[3] + this.deleteTarget(targetID);

            }
        }
        
        result[4] = annotationDao.deleteAnnotationFromAllNotebooks(annotationID);
        
        result[0] = annotationDao.deleteAnnotation(annotationID);
        return result;
    }
    
    ////////////////////// DELETERS ////////////////////////
    @Override
    public int deleteTarget(Number internalID) {
        if (internalID == null) {
            logger.debug("internalID of the target is null.");
            return 0;
        }
        
        if (annotationDao.targetIsInUse(internalID)) {
            logger.debug("The target is in use, and cannot be deleted.");
            return 0;
        }
        
        return targetDao.deleteTarget(internalID);

    }

    @Override
    public boolean deleteNotebook(Number notebookID) {
        if (notebookDao.deleteAllPermissionsForNotebook(notebookID) || notebookDao.deleteAllAnnotationsFromNotebook(notebookID)) {
            return notebookDao.deleteNotebook(notebookID);
        } else {
            return false;
        }
    }

////////////// HELPERS ////////////////////
    ////////////////////////////////////////
    @Override
    public ResponseBody makeAnnotationResponseEnvelope(Number annotationID) {
        ResponseBody result = new ResponseBody();
        Annotation annotation = this.getAnnotation(annotationID);
        result.setAnnotation(annotation);
        List<String> targetsNoCached = this.getTargetsWithNoCachedRepresentation(annotationID);
        ActionList actionList = new ActionList();
        result.setActionList(actionList);
        actionList.getAction().addAll(makeActionList(targetsNoCached, AnnotationActionName.CREATE_CACHED_REPRESENTATION.value()));
        return result;
    }

    @Override
    public ResponseBody makeNotebookResponseEnvelope(Number notebookID) {
        ResponseBody result = new ResponseBody();
        result.setPermissions(null);
        Notebook notebook = this.getNotebook(notebookID);
        result.setNotebook(notebook);
        return result;
    }

    @Override
    public ResponseBody makePermissionResponseEnvelope(Number resourceID, Resource resource) {
        ResponseBody result = new ResponseBody();
        UserWithPermissionList permissions = this.getPermissions(resourceID, resource);
        result.setPermissions(permissions);
        List<String> usersWithNoInfo = this.getUsersWithNoInfo(resourceID);
        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 {
                List<Action> result = new ArrayList<Action>();
                for (String resourceURI : resourceURIs) {
                    Action action = new Action();
                    result.add(action);
                    action.setMessage(message);
                    action.setObject(resourceURI);
                }
                return result;
            }
        } else {
            return null;
        }
    }

    //// priveee ///
    private Target createFreshTarget(TargetInfo targetInfo) {
        Target target = new Target();
        target.setLink(targetInfo.getLink());
        target.setVersion(targetInfo.getVersion());
        return target;
    }

    private int addTargets(Annotation annotation, Number annotationID) {
        List<TargetInfo> targets = annotation.getTargets().getTargetInfo();
        Map<String, String> targetIdPairs = addTargetsForAnnotation(annotationID, targets);
        AnnotationBody annotationBody = annotation.getBody();
        String bodyText;
        String newBodyText;
        String mimeType;
        if (annotationBody.getXmlBody() != null) {
            bodyText = Helpers.elementToString(annotation.getBody().getXmlBody().getAny());
            mimeType = annotationBody.getXmlBody().getMimeType();
        } else {
            if (annotation.getBody().getTextBody() != null) {
                bodyText = annotation.getBody().getTextBody().getBody();
                mimeType = annotationBody.getTextBody().getMimeType();
            } else {
                logger.error("The client has sent ill-formed annotation body.");
                return -1;
            }
        }
        newBodyText = Helpers.replace(bodyText, targetIdPairs);
        return annotationDao.updateAnnotationBody(annotationID, newBodyText, mimeType, annotationBody.getXmlBody() != null);
    }

    private int addPrincipalsPermissions(List<UserWithPermission> permissions, Number annotationID) {
        int addedPermissions = 0;
        for (UserWithPermission permission : permissions) {
            addedPermissions = addedPermissions + annotationDao.addAnnotationPrincipalPermission(annotationID, userDao.getInternalIDFromURI(permission.getRef()), permission.getPermission());

        }
        return addedPermissions;
    }

    private TargetInfo getTargetInfoFromTarget(Target target) {
        TargetInfo targetInfo = new TargetInfo();
        targetInfo.setRef(target.getURI());
        targetInfo.setLink(target.getLink());
        targetInfo.setVersion(target.getVersion());
        return targetInfo;
    }
}