You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
429 lines
16 KiB
Java
429 lines
16 KiB
Java
package org.gcube.data.access.storagehub.services;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import javax.enterprise.context.RequestScoped;
|
|
import javax.inject.Inject;
|
|
import javax.jcr.ItemNotFoundException;
|
|
import javax.jcr.Node;
|
|
import javax.jcr.NodeIterator;
|
|
import javax.jcr.RepositoryException;
|
|
import javax.jcr.Session;
|
|
import javax.servlet.ServletContext;
|
|
import javax.ws.rs.Consumes;
|
|
import javax.ws.rs.DELETE;
|
|
import javax.ws.rs.FormParam;
|
|
import javax.ws.rs.GET;
|
|
import javax.ws.rs.POST;
|
|
import javax.ws.rs.PUT;
|
|
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.Response;
|
|
import javax.ws.rs.core.Response.Status;
|
|
|
|
import org.apache.jackrabbit.api.JackrabbitSession;
|
|
import org.apache.jackrabbit.api.security.user.User;
|
|
import org.gcube.common.gxrest.response.outbound.GXOutboundErrorResponse;
|
|
import org.gcube.common.storagehub.model.Excludes;
|
|
import org.gcube.common.storagehub.model.Paths;
|
|
import org.gcube.common.storagehub.model.exceptions.BackendGenericError;
|
|
import org.gcube.common.storagehub.model.exceptions.IdNotFoundException;
|
|
import org.gcube.common.storagehub.model.exceptions.InvalidCallParameters;
|
|
import org.gcube.common.storagehub.model.exceptions.StorageHubException;
|
|
import org.gcube.common.storagehub.model.exceptions.UserNotAuthorizedException;
|
|
import org.gcube.common.storagehub.model.items.AbstractFileItem;
|
|
import org.gcube.common.storagehub.model.items.Item;
|
|
import org.gcube.common.storagehub.model.items.nodes.Owner;
|
|
import org.gcube.common.storagehub.model.messages.Message;
|
|
import org.gcube.common.storagehub.model.service.ItemList;
|
|
import org.gcube.common.storagehub.model.types.ItemAction;
|
|
import org.gcube.common.storagehub.model.types.MessageList;
|
|
import org.gcube.common.storagehub.model.types.NodeProperty;
|
|
import org.gcube.data.access.storagehub.Constants;
|
|
import org.gcube.data.access.storagehub.PathUtil;
|
|
import org.gcube.data.access.storagehub.StorageHubAppllicationManager;
|
|
import org.gcube.data.access.storagehub.Utils;
|
|
import org.gcube.data.access.storagehub.accounting.AccountingHandler;
|
|
import org.gcube.data.access.storagehub.handlers.CredentialHandler;
|
|
import org.gcube.data.access.storagehub.handlers.TrashHandler;
|
|
import org.gcube.data.access.storagehub.handlers.items.Item2NodeConverter;
|
|
import org.gcube.data.access.storagehub.handlers.items.Item2NodeConverter.Values;
|
|
import org.gcube.data.access.storagehub.handlers.items.Node2ItemConverter;
|
|
import org.gcube.data.access.storagehub.handlers.plugins.FolderPluginHandler;
|
|
import org.gcube.data.access.storagehub.types.MessageSharable;
|
|
import org.gcube.smartgears.annotations.ManagedBy;
|
|
import org.gcube.smartgears.utils.InnerMethodName;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
@Path("messages")
|
|
@ManagedBy(StorageHubAppllicationManager.class)
|
|
public class MessageManager extends Impersonable{
|
|
|
|
private static final Logger log = LoggerFactory.getLogger(MessageManager.class);
|
|
|
|
RepositoryInitializer repository = StorageHubAppllicationManager.repository;
|
|
|
|
@Inject
|
|
AccountingHandler accountingHandler;
|
|
|
|
@RequestScoped
|
|
@PathParam("id")
|
|
String id;
|
|
|
|
@Context
|
|
ServletContext context;
|
|
|
|
@Inject PathUtil pathUtil;
|
|
|
|
@Inject Node2ItemConverter node2Item;
|
|
@Inject Item2NodeConverter item2Node;
|
|
|
|
@Inject TrashHandler trashHandler;
|
|
|
|
@GET
|
|
@Path("{id}")
|
|
@Produces(MediaType.APPLICATION_JSON)
|
|
public Message getById(){
|
|
InnerMethodName.instance.set("getMessageById");
|
|
Session ses = null;
|
|
Message toReturn = null;
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
Node messageNode = ses.getNodeByIdentifier(id);
|
|
toReturn = node2Item.getMessageItem(messageNode);
|
|
checkRights(currentUser, toReturn);
|
|
}catch (ItemNotFoundException e) {
|
|
log.error("id {} not found",id,e);
|
|
GXOutboundErrorResponse.throwException(new IdNotFoundException(id, e), Status.NOT_FOUND);
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}catch(StorageHubException she ){
|
|
log.error(she.getErrorMessage(), she);
|
|
GXOutboundErrorResponse.throwException(she, Response.Status.fromStatusCode(she.getStatus()));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
|
|
return toReturn;
|
|
}
|
|
|
|
@DELETE
|
|
@Path("{id}")
|
|
public void deleteById(){
|
|
InnerMethodName.instance.set("deleteMessageById");
|
|
Session ses = null;
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
Node messageNode = ses.getNodeByIdentifier(id);
|
|
Message message = node2Item.getMessageItem(messageNode);
|
|
Node personalNode = checkRights(currentUser, message);
|
|
|
|
if (countSharedSet(messageNode)>1)
|
|
personalNode.removeShare();
|
|
else {
|
|
if (message.isWithAttachments()) {
|
|
Node attachmentNode = messageNode.getNode(Constants.ATTACHMENTNODE_NAME);
|
|
List<Item> attachments = Utils.getItemList(attachmentNode, Excludes.GET_ONLY_CONTENT, null, true, AbstractFileItem.class);
|
|
trashHandler.removeOnlyNodesContent(ses, attachments);
|
|
}
|
|
messageNode.removeSharedSet();
|
|
}
|
|
ses.save();
|
|
}catch (ItemNotFoundException e) {
|
|
log.error("id {} not found",id,e);
|
|
GXOutboundErrorResponse.throwException(new IdNotFoundException(id, e), Status.NOT_FOUND);
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}catch(StorageHubException she ){
|
|
log.error(she.getErrorMessage(), she);
|
|
GXOutboundErrorResponse.throwException(she, Response.Status.fromStatusCode(she.getStatus()));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
}
|
|
|
|
@GET
|
|
@Path("{id}/attachments")
|
|
@Produces(MediaType.APPLICATION_JSON)
|
|
public ItemList getAttachments(){
|
|
InnerMethodName.instance.set("getAttachmentsByMessageId");
|
|
Session ses = null;
|
|
List<Item> attachments = new ArrayList<>();
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
Node messageNode = ses.getNodeByIdentifier(id);
|
|
Message messageItem = node2Item.getMessageItem(messageNode);
|
|
checkRights(currentUser, messageItem);
|
|
Node attachmentNode = messageNode.getNode(Constants.ATTACHMENTNODE_NAME);
|
|
attachments = Utils.getItemList(attachmentNode, Excludes.GET_ONLY_CONTENT, null, true, AbstractFileItem.class);
|
|
}catch (ItemNotFoundException e) {
|
|
log.error("id {} not found",id,e);
|
|
GXOutboundErrorResponse.throwException(new IdNotFoundException(id, e), Status.NOT_FOUND);
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}catch(StorageHubException she ){
|
|
log.error(she.getErrorMessage(), she);
|
|
GXOutboundErrorResponse.throwException(she, Response.Status.fromStatusCode(she.getStatus()));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
|
|
return new ItemList(attachments);
|
|
}
|
|
|
|
@GET
|
|
@Path("inbox")
|
|
@Produces(MediaType.APPLICATION_JSON)
|
|
public MessageList getReceivedMessages(@QueryParam("reduceBody") Integer reduceBody){
|
|
InnerMethodName.instance.set("getReceivedMessages");
|
|
Session ses = null;
|
|
List<Message> toReturn = null;
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
|
|
Node node = ses.getNode(pathUtil.getInboxPath(currentUser).toPath());
|
|
|
|
//return sorted for createdTime
|
|
toReturn = getMessages(node, reduceBody);
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
|
|
return new MessageList(toReturn);
|
|
}
|
|
|
|
@GET
|
|
@Path("sent")
|
|
@Produces(MediaType.APPLICATION_JSON)
|
|
public MessageList getSentMessages(@QueryParam("reduceBody") Integer reduceBody){
|
|
InnerMethodName.instance.set("getSentMessages");
|
|
Session ses = null;
|
|
List<Message> toReturn = null;
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
|
|
Node node = ses.getNode(pathUtil.getOutboxPath(currentUser).toPath());
|
|
|
|
toReturn = getMessages(node, reduceBody);
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
|
|
return new MessageList(toReturn);
|
|
}
|
|
|
|
@PUT
|
|
@Path("{id}/{prop}")
|
|
@Consumes(MediaType.APPLICATION_JSON)
|
|
public void setProperty(@PathParam("prop") String property,Object value){
|
|
InnerMethodName.instance.set("setPropertyOnMessage("+property+")");
|
|
Session ses = null;
|
|
try{
|
|
ses = repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
Node messageNode = ses.getNodeByIdentifier(id);
|
|
Message messageItem = node2Item.getMessageItem(messageNode);
|
|
checkRights(currentUser, messageItem);
|
|
Values val = Item2NodeConverter.getObjectValue(value.getClass(), value);
|
|
messageNode.setProperty(property, val.getValue());
|
|
ses.save();
|
|
}catch (ItemNotFoundException e) {
|
|
log.error("id {} not found",id,e);
|
|
GXOutboundErrorResponse.throwException(new IdNotFoundException(id, e), Status.NOT_FOUND);
|
|
}catch(StorageHubException she ){
|
|
log.error(she.getErrorMessage(), she);
|
|
GXOutboundErrorResponse.throwException(she, Response.Status.fromStatusCode(she.getStatus()));
|
|
}catch( Exception re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
@POST
|
|
@Path("send")
|
|
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
|
|
public String sendMessage(@FormParam("to[]") List<String> addresses,
|
|
@FormParam("subject") String subject, @FormParam("body") String body,
|
|
@FormParam("attachments[]") List<String> attachments){
|
|
InnerMethodName.instance.set("sendMessage");
|
|
JackrabbitSession ses = null;
|
|
String messageId = null;
|
|
try{
|
|
if (addresses.size()==0 || body==null || subject==null)
|
|
throw new InvalidCallParameters();
|
|
|
|
log.debug("attachments send are {}",attachments);
|
|
|
|
ses = (JackrabbitSession) repository.getRepository().login(CredentialHandler.getAdminCredentials(context));
|
|
|
|
Message message = new MessageSharable();
|
|
message.setAddresses(addresses.toArray(new String[0]));
|
|
message.setSubject(subject);
|
|
message.setBody(body);
|
|
message.setName(UUID.randomUUID().toString());
|
|
User user = ses.getUserManager().getAuthorizable(currentUser, User.class);
|
|
Owner owner = new Owner();
|
|
owner.setUserId(user.getID());
|
|
owner.setUserName(user.getPrincipal().getName());
|
|
message.setSender(owner);
|
|
Node outbox = ses.getNode(pathUtil.getOutboxPath(currentUser).toPath());
|
|
Node messageNode = item2Node.getNode(outbox, message);
|
|
ses.save();
|
|
if (attachments!=null && !attachments.isEmpty()) {
|
|
saveAttachments(ses, messageNode, attachments);
|
|
ses.save();
|
|
}
|
|
for (String to: addresses)
|
|
try {
|
|
String userMessagePath = Paths.append(pathUtil.getInboxPath(to), messageNode.getName()).toPath();
|
|
ses.getWorkspace().clone(ses.getWorkspace().getName(), messageNode.getPath(), userMessagePath, false);
|
|
}catch (Exception e) {
|
|
log.warn("message not send to {}",to,e);
|
|
}
|
|
|
|
ses.save();
|
|
messageId = messageNode.getIdentifier();
|
|
}catch(RepositoryException re){
|
|
log.error("jcr error getting item", re);
|
|
GXOutboundErrorResponse.throwException(new BackendGenericError("jcr error getting item", re));
|
|
}catch(StorageHubException she ){
|
|
log.error(she.getErrorMessage(), she);
|
|
GXOutboundErrorResponse.throwException(she, Response.Status.fromStatusCode(she.getStatus()));
|
|
}finally{
|
|
if (ses!=null)
|
|
ses.logout();
|
|
}
|
|
|
|
return messageId;
|
|
}
|
|
|
|
|
|
|
|
private Node saveAttachments(Session ses, Node messageNode , List<String> attachments) throws RepositoryException, BackendGenericError{
|
|
Node attachmentNode = messageNode.getNode(Constants.ATTACHMENTNODE_NAME);
|
|
|
|
for (String itemId: attachments) {
|
|
Node node = ses.getNodeByIdentifier(itemId);
|
|
Item item = node2Item.getItem(node, Excludes.GET_ONLY_CONTENT);
|
|
Node newNode = copyNode(ses, attachmentNode, item);
|
|
//removes accounting if exists
|
|
if (newNode.hasNode(NodeProperty.ACCOUNTING.toString()))
|
|
newNode.getNode(NodeProperty.ACCOUNTING.toString()).remove();
|
|
}
|
|
return messageNode;
|
|
}
|
|
|
|
//returns Messages sorted by createdTime
|
|
private List<Message> getMessages(Node node, Integer reduceBody) throws RepositoryException{
|
|
List<Message> messages = new ArrayList<Message>();
|
|
NodeIterator nodeIt = node.getNodes();
|
|
while(nodeIt.hasNext()) {
|
|
Node child = nodeIt.nextNode();
|
|
log.info("message type "+child.getPrimaryNodeType().getName());
|
|
Message message = node2Item.getMessageItem(child);
|
|
if (message == null) {
|
|
log.info("message discarded");
|
|
continue;
|
|
}
|
|
|
|
if (reduceBody != null && reduceBody>0 && message.getBody().length()>reduceBody )
|
|
message.setBody(message.getBody().substring(0, reduceBody));
|
|
insertOrdered(messages, message);
|
|
}
|
|
return messages;
|
|
}
|
|
|
|
private void insertOrdered(List<Message> messages, Message toInsert) {
|
|
if (messages.isEmpty())
|
|
messages.add(toInsert);
|
|
else {
|
|
int i;
|
|
for ( i=0 ; i<messages.size(); i++)
|
|
if (messages.get(i).getCreationTime().getTimeInMillis()<=toInsert.getCreationTime().getTimeInMillis())
|
|
break;
|
|
messages.add(i, toInsert);
|
|
}
|
|
}
|
|
|
|
|
|
private Node checkRights(String user, Message messageItem) throws RepositoryException, StorageHubException{
|
|
Node personalNode = null;
|
|
Node messageNode = (Node) messageItem.getRelatedNode();
|
|
if (messageNode.getPath().startsWith(pathUtil.getInboxPath(user).toPath()))
|
|
return messageNode;
|
|
|
|
NodeIterator nodeIt = messageNode.getSharedSet();
|
|
while (nodeIt.hasNext()) {
|
|
Node node = nodeIt.nextNode();
|
|
if (node.getPath().startsWith(pathUtil.getInboxPath(user).toPath()))
|
|
personalNode = node;
|
|
}
|
|
if (personalNode == null &&
|
|
!messageItem.getSender().getUserName().equals(user) && !Arrays.asList(messageItem.getAddresses()).contains(user))
|
|
throw new UserNotAuthorizedException("user "+currentUser+"cannot read message with id "+id);
|
|
return personalNode== null ? messageNode : personalNode;
|
|
}
|
|
|
|
//TODO: move in a common place
|
|
@Inject FolderPluginHandler folderPluginHandler;
|
|
|
|
private Node copyNode(Session session, Node destination, Item itemToCopy) throws RepositoryException, BackendGenericError{
|
|
//it needs to be locked ??
|
|
Node nodeToCopy = ((Node)itemToCopy.getRelatedNode());
|
|
String uniqueName = Utils.checkExistanceAndGetUniqueName(session, destination,itemToCopy.getName() );
|
|
String newPath= String.format("%s/%s", destination.getPath(), uniqueName);
|
|
session.getWorkspace().copy(nodeToCopy.getPath(), newPath);
|
|
Node newNode = session.getNode(newPath);
|
|
|
|
if (itemToCopy instanceof AbstractFileItem) {
|
|
AbstractFileItem newNodeItem = node2Item.getItem(newNode, Excludes.EXCLUDE_ACCOUNTING);
|
|
newNodeItem.getContent().setRemotePath(newPath);
|
|
String newStorageID = folderPluginHandler.getDefault().getStorageBackend().onCopy(newNodeItem);
|
|
newNodeItem.getContent().setStorageId(newStorageID);
|
|
item2Node.replaceContent(newNode, newNodeItem, ItemAction.CLONED);
|
|
}
|
|
|
|
Utils.setPropertyOnChangeNode(newNode, currentUser, ItemAction.CLONED);
|
|
newNode.setProperty(NodeProperty.PORTAL_LOGIN.toString(), currentUser);
|
|
newNode.setProperty(NodeProperty.IS_PUBLIC.toString(), false);
|
|
newNode.setProperty(NodeProperty.TITLE.toString(), uniqueName);
|
|
return newNode;
|
|
}
|
|
|
|
private int countSharedSet(Node node) throws RepositoryException{
|
|
int count =0;
|
|
NodeIterator it = node.getSharedSet();
|
|
while (it.hasNext()) {
|
|
count ++;
|
|
it.next();
|
|
}
|
|
return count;
|
|
}
|
|
}
|