820 lines
28 KiB
Java
820 lines
28 KiB
Java
package org.gcube.portlets.user.workspaceexplorerapp.server;
|
|
|
|
import java.net.URL;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import javax.servlet.http.HttpSession;
|
|
|
|
import org.gcube.common.encryption.StringEncrypter;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.common.storagehubwrapper.server.tohl.Workspace;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceItem;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceItemType;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.items.FileItem;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.client.WorkspaceExplorerAppConstants;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.client.rpc.WorkspaceExplorerAppService;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.server.workspace.ItemBuilder;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.server.workspace.WorkspaceInstance;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.server.workspace.WsUtil;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.shared.FilterCriteria;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.shared.Item;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.shared.ItemType;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.shared.WorkspaceNavigatorServiceException;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
|
|
|
|
|
|
// TODO: Auto-generated Javadoc
|
|
/**
|
|
* The Class WorkspaceExplorerAppServiceImpl.
|
|
*
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
|
|
* Jul 3, 2017
|
|
*/
|
|
@SuppressWarnings("serial")
|
|
public class WorkspaceExplorerAppServiceImpl extends RemoteServiceServlet implements WorkspaceExplorerAppService {
|
|
|
|
public static final String THE_WORKSPACE_SHUB_INSTANCIED = "THE_WORKSPACE_SHUB_INSTANCIED";
|
|
/**
|
|
*
|
|
*/
|
|
public static final Logger logger = LoggerFactory.getLogger(WorkspaceExplorerAppServiceImpl.class);
|
|
public static final String UTF_8 = "UTF-8";
|
|
|
|
|
|
/**
|
|
* Gets the workspace.
|
|
*
|
|
* @return the workspace
|
|
* @throws Exception
|
|
*/
|
|
private Workspace getWorkspace() throws Exception {
|
|
HttpSession httpSession = this.getThreadLocalRequest().getSession();
|
|
Workspace workspace = (Workspace) httpSession.getAttribute(THE_WORKSPACE_SHUB_INSTANCIED);
|
|
|
|
if(workspace==null) {
|
|
WorkspaceInstance workspaceInstance = new WorkspaceInstance(httpSession);
|
|
workspace = workspaceInstance.get();
|
|
httpSession.setAttribute(THE_WORKSPACE_SHUB_INSTANCIED, workspace);
|
|
}
|
|
|
|
return workspace;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
public Item getRoot(List<ItemType> showableTypes, boolean purgeEmpyFolders, FilterCriteria filterCriteria) throws WorkspaceNavigatorServiceException {
|
|
logger.debug("getRoot showableTypes: "+showableTypes+" purgeEmpyFolders: "+purgeEmpyFolders+" filterCriteria: "+ filterCriteria);
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
logger.trace("Start getRoot...");
|
|
|
|
org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder root = workspace.getRoot();
|
|
|
|
logger.trace("GetRoot - Replyiing root");
|
|
long startTime = System.currentTimeMillis();
|
|
logger.trace("start time - " + startTime);
|
|
|
|
|
|
Item rootItem = ItemBuilder.getItem(null, root, root.getPath(), showableTypes, filterCriteria);
|
|
//adding the children
|
|
List<? extends WorkspaceItem> children = workspace.getChildren(root.getId());
|
|
rootItem = ItemBuilder.addChildren(rootItem, "", children, showableTypes, filterCriteria);
|
|
rootItem.setName(WorkspaceExplorerAppConstants.HOME_LABEL);
|
|
rootItem.setIsRoot(true);
|
|
|
|
/* SPECIAL FOLDERS
|
|
Item specialFolders = ItemBuilder.getItem(null, specials, showableTypes, filterCriteria, 2);
|
|
specialFolders.setShared(true);
|
|
rootItem.addChild(specialFolders);
|
|
*/
|
|
if (purgeEmpyFolders) {
|
|
rootItem = ItemBuilder.purgeEmptyFolders(rootItem);
|
|
}
|
|
|
|
logger.trace("Returning:");
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
logger.info("end time - " + time);
|
|
|
|
Collections.sort(rootItem.getChildren(), new ItemComparator());
|
|
logger.info("Returning children size: "+rootItem.getChildren().size());
|
|
|
|
return rootItem;
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error during root retrieving", e);
|
|
throw new WorkspaceNavigatorServiceException("Sorry, an error occurred when performing get root");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the folder.
|
|
*
|
|
* @param item the item
|
|
* @param showableTypes the showable types
|
|
* @param purgeEmpyFolders the purge empy folders
|
|
* @param filterCriteria the filter criteria
|
|
* @return the folder
|
|
* @throws WorkspaceNavigatorServiceException the workspace navigator service exception
|
|
*/
|
|
@Override
|
|
public Item getFolder(Item item, List<ItemType> showableTypes, boolean purgeEmpyFolders, FilterCriteria filterCriteria) throws WorkspaceNavigatorServiceException {
|
|
logger.debug("getFolder item: "+item+" showableTypes: "+showableTypes+" purgeEmpyFolders: "+purgeEmpyFolders+" filterCriteria: "+filterCriteria);
|
|
|
|
WorkspaceItem workspaceItem = null;
|
|
Workspace workspace = null;
|
|
try {
|
|
|
|
if(item==null || item.getId()==null)
|
|
throw new Exception("Item id is null");
|
|
|
|
workspace = getWorkspace();
|
|
workspaceItem = workspace.getItem(item.getId());
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error during item retrieving", e);
|
|
throw new WorkspaceNavigatorServiceException("Sorry, an error occurred when performing get folder. Does it still exist?");
|
|
}
|
|
|
|
if(workspaceItem != null && workspaceItem.isFolder()) {
|
|
|
|
try {
|
|
|
|
WorkspaceItem folder = workspaceItem;
|
|
|
|
logger.trace("GetFolder - Replyiing folder");
|
|
long startTime = System.currentTimeMillis();
|
|
logger.trace("start time - " + startTime);
|
|
|
|
String path = item.getPath()!=null && !item.getPath().isEmpty()?item.getPath():folder.getPath();
|
|
Item itemFolder = ItemBuilder.getItem(null, folder, path, showableTypes, filterCriteria);
|
|
//adding the children
|
|
List<? extends WorkspaceItem> children = workspace.getChildren(itemFolder.getId());
|
|
itemFolder = ItemBuilder.addChildren(itemFolder, path, children, showableTypes, filterCriteria);
|
|
// _log.trace("Only showable types:");
|
|
|
|
if (purgeEmpyFolders) {
|
|
itemFolder = ItemBuilder.purgeEmptyFolders(itemFolder);
|
|
}
|
|
|
|
logger.trace("Returning:");
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
logger.info("end time - " + time);
|
|
|
|
Collections.sort(itemFolder.getChildren(), new ItemComparator());
|
|
|
|
return itemFolder;
|
|
}catch (Exception e) {
|
|
throw new WorkspaceNavigatorServiceException(e.getMessage());
|
|
}
|
|
|
|
}else {
|
|
logger.error("The item requested is not a folder");
|
|
throw new WorkspaceNavigatorServiceException("Error, the item requested is not a folder");
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
// /**
|
|
// * Gets the item by category.
|
|
// *
|
|
// * @param category the category
|
|
// * @return the item by category
|
|
// * @throws WorkspaceNavigatorServiceException the workspace navigator service exception
|
|
// */
|
|
// /* (non-Javadoc)
|
|
// * @see org.gcube.portlets.widgets.wsexplorer.client.rpc.WorkspaceExplorerService#getItemByCategory(org.gcube.portlets.widgets.wsexplorer.shared.ItemCategory)
|
|
// */
|
|
// @Override
|
|
// public Item getItemByCategory(ItemCategory category) throws WorkspaceNavigatorServiceException{
|
|
// logger.trace("GetItemByCategory category: "+category);
|
|
// throw new WorkspaceNavigatorServiceException("The method getItemByCategory is not implemented");
|
|
// }
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
public Item getMySpecialFolder(List<ItemType> showableTypes, boolean purgeEmpyFolders, FilterCriteria filterCriteria) throws WorkspaceNavigatorServiceException {
|
|
logger.trace("GetMySpecialFolder showableTypes: "+showableTypes+" purgeEmpyFolders: "+purgeEmpyFolders+" filterCriteria: "+filterCriteria);
|
|
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
WorkspaceItem folder = workspace.getMySpecialFolders();
|
|
long startTime = System.currentTimeMillis();
|
|
|
|
logger.trace("start time - " + startTime);
|
|
Item itemFolder = ItemBuilder.getItem(null, folder, folder.getPath(), showableTypes, filterCriteria);
|
|
//adding the children
|
|
List<? extends WorkspaceItem> children = workspace.getChildren(itemFolder.getId());
|
|
itemFolder = ItemBuilder.addChildren(itemFolder, "", children, showableTypes, filterCriteria);
|
|
|
|
//OVERRIDING VRE FOLDERS NAME - SET SPECIAL FOLDER /Workspace/MySpecialFolders
|
|
itemFolder.setName(WorkspaceExplorerAppConstants.VRE_FOLDERS_LABEL);
|
|
itemFolder.setSpecialFolder(true);
|
|
logger.trace("Builded MySpecialFolder: "+itemFolder);
|
|
logger.trace("Only showable types:");
|
|
if (purgeEmpyFolders) {
|
|
itemFolder = ItemBuilder.purgeEmptyFolders(itemFolder);
|
|
}
|
|
|
|
logger.trace("Returning:");
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
logger.trace("end time - " + time);
|
|
Collections.sort(itemFolder.getChildren(), new ItemComparator());
|
|
return itemFolder;
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error during special folders retrieving", e);
|
|
throw new WorkspaceNavigatorServiceException("Sorry, an error occurred when performing get My Special Folder");
|
|
}
|
|
}
|
|
|
|
// /**
|
|
// * {@inheritDoc}
|
|
// */
|
|
// @Override
|
|
// public boolean checkName(String name) throws WorkspaceNavigatorServiceException {
|
|
// logger.trace("checkName name: "+name);
|
|
// throw new WorkspaceNavigatorServiceException("The method checkName is not implemented");
|
|
//// try {
|
|
//// Workspace workspace = WsUtil.getWorkspace(this.getThreadLocalRequest().getSession());
|
|
//// return workspace.isValidName(name);
|
|
//// } catch (Exception e) {
|
|
//// logger.error("Error during folder retrieving", e);
|
|
//// throw new WorkspaceNavigatorServiceException(e.getMessage());
|
|
//// }
|
|
// }
|
|
|
|
/*protected void printName(String indentation, Item item)
|
|
{
|
|
if(item!=null){
|
|
_log.trace(indentation+item.getName());
|
|
for (Item child:item.getChildren()) printName(indentation+"\t", child);
|
|
}
|
|
}*/
|
|
|
|
/**
|
|
* Gets Breadcrumbs (the list of parents) by item identifier.
|
|
*
|
|
* @param itemIdentifier the item identifier
|
|
* @param includeItemAsParent - if parameter is true and item passed in input is a folder, the folder is included in path returned as last parent
|
|
* @return the list parents by item identifier
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public List<Item> getBreadcrumbsByItemIdentifier(String itemIdentifier, boolean includeItemAsParent) throws Exception {
|
|
logger.trace("ListParents By Item Identifier "+ itemIdentifier);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
WorkspaceItem wsItem = workspace.getItem(itemIdentifier);
|
|
logger.trace("workspace retrieve item name: "+wsItem.getName());
|
|
List<? extends WorkspaceItem> parents = workspace.getParentsById(itemIdentifier);
|
|
logger.trace("parents size: "+parents.size());
|
|
Item[] arrayParents;
|
|
|
|
|
|
switch (parents.size()) {
|
|
case 0: // itemIdentifier is ROOT
|
|
logger.trace("itemIdentifier isRoot...");
|
|
if (includeItemAsParent) { //ADDING ROOT
|
|
org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder wsFolder =
|
|
(org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder) wsItem;
|
|
Item root = ItemBuilder.buildFolderForBreadcrumbs(wsFolder, null);
|
|
List<Item> listParents = new ArrayList<Item>(1);
|
|
listParents.add(root);
|
|
//workspaceLogger.trace("returning: "+listParents.toString());
|
|
return listParents;
|
|
}
|
|
else{
|
|
logger.trace("returning empty list");
|
|
return new ArrayList<Item>(); // empty list
|
|
}
|
|
|
|
case 1: //itemIdentifier is first level from root
|
|
logger.trace("itemIdentifier is first level...");
|
|
List<Item> listParents = new ArrayList<Item>();
|
|
org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder wsRootFolder = (org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder) parents.get(0); //isRoot
|
|
Item root = ItemBuilder.buildFolderForBreadcrumbs(wsRootFolder, null);
|
|
Item parent = null;
|
|
if(includeItemAsParent){
|
|
org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder wsFolder1 =
|
|
(org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder) workspace.getItem(itemIdentifier); //root
|
|
parent = ItemBuilder.buildFolderForBreadcrumbs(wsFolder1, null);
|
|
}
|
|
listParents.add(root);
|
|
if(parent!=null)
|
|
listParents.add(parent);
|
|
// workspaceLogger.trace("returning: "+listParents.toString());
|
|
return listParents;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
WorkspaceItem lastItem = parents.get(parents.size()-1);
|
|
|
|
//CONVERTING LAST ELEMENT IF NECESSARY
|
|
logger.trace("converting last element..");
|
|
if(includeItemAsParent && lastItem.isFolder()){ //FIX BUG #298
|
|
arrayParents = new Item[parents.size()];
|
|
logger.debug("including last item into path: "+lastItem.getName());
|
|
arrayParents[parents.size()-1] = ItemBuilder.buildFolderForBreadcrumbs((WorkspaceFolder) lastItem, null);
|
|
}else
|
|
arrayParents = new Item[parents.size()-1];
|
|
|
|
/** HANDLE MY_SPECIAL_FOLDER TO AVOID COMPLETE PATH WORKSPACE/MY_SPECIAL_FOLDER
|
|
* BUT RETURNING ONLY /MY_SPECIAL_FOLDER
|
|
*/
|
|
if(wsItem.isFolder()){
|
|
if(ItemBuilder.isSpecialFolder((WorkspaceFolder) wsItem, lastItem.isRoot())){
|
|
return new ArrayList<Item>(Arrays.asList(arrayParents));
|
|
}
|
|
}
|
|
|
|
//CONVERTING PATH
|
|
logger.trace("converting path from second-last..");
|
|
for (int i = parents.size()-2; i >= 0; i--) {
|
|
WorkspaceFolder wsParentFolder = (WorkspaceFolder) parents.get(i);
|
|
arrayParents[i] = ItemBuilder.buildFolderForBreadcrumbs(wsParentFolder, null);
|
|
if(arrayParents[i].isSpecialFolder()){ //SKIP HOME PARENT FOR MY_SPECIAL_FOLDER
|
|
logger.info("arrayParents index "+i+" is special folder, exit");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//SET PARENTS
|
|
logger.trace("setting parents..");
|
|
for(int i=0; i<arrayParents.length-1; i++){
|
|
|
|
Item parent = arrayParents[i];
|
|
Item fileModel = arrayParents[i+1];
|
|
fileModel.setParent(parent);
|
|
}
|
|
|
|
logger.trace("ListParents return size: "+arrayParents.length);
|
|
if(arrayParents[0]==null){ //EXIT BY BREAK IN CASE OF SPECIAL FOLDER
|
|
List<Item> breadcrumbs = new ArrayList<Item>(arrayParents.length-1);
|
|
for (int i=1; i<arrayParents.length; i++) {
|
|
breadcrumbs.add(arrayParents[i]);
|
|
}
|
|
return breadcrumbs;
|
|
}
|
|
else {
|
|
return new ArrayList<Item>(Arrays.asList(arrayParents));
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error in get List Parents By Item Identifier ", e);
|
|
throw new Exception("Sorry, an error occurred during path retrieving!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the parents by item identifier to limit.
|
|
* when limit is reached parents are null
|
|
* @param itemIdentifier the item identifier
|
|
* @param parentLimit the parent limit
|
|
* @param includeItemAsParent the include item as parent
|
|
* @return the parents by item identifier to limit
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public List<Item> getBreadcrumbsByItemIdentifierToParentLimit(String itemIdentifier, String parentLimit, boolean includeItemAsParent) throws Exception {
|
|
logger.trace("getBreadcrumbsByItemIdentifierToParentLimit by Item Identifier " + itemIdentifier +" and limit: "+parentLimit + " and includeItemAsParent: "+includeItemAsParent);
|
|
try {
|
|
|
|
Workspace workspace = getWorkspace();
|
|
WorkspaceItem wsItem = workspace.getItem(itemIdentifier);
|
|
logger.trace("workspace retrieve item name: "+wsItem.getName());
|
|
List<? extends WorkspaceItem> parents = null;
|
|
try{
|
|
parents = workspace.getParentsById(itemIdentifier);
|
|
}catch(Exception e){
|
|
logger.error("Error on getting list of parents from HL for id: "+itemIdentifier, e);
|
|
parents = new ArrayList<WorkspaceItem>();
|
|
}
|
|
|
|
if(parents==null) //avoiding null
|
|
parents = new ArrayList<WorkspaceItem>();
|
|
|
|
if(logger.isDebugEnabled()) {
|
|
for (WorkspaceItem workspaceItem : parents) {
|
|
logger.debug("the parent is: "+workspaceItem.getName());
|
|
}
|
|
}
|
|
|
|
|
|
List<Item> arrayParents = new ArrayList<Item>();
|
|
parentLimit = parentLimit!=null?parentLimit:"";
|
|
|
|
switch (parents.size()) {
|
|
case 0: // itemIdentifier is ROOT
|
|
logger.trace("itemIdentifier isRoot...");
|
|
if (includeItemAsParent) { //ADDIND ROOT
|
|
WorkspaceFolder wsFolder =(WorkspaceFolder) wsItem;
|
|
Item root = ItemBuilder.buildFolderForBreadcrumbs(wsFolder, null);
|
|
List<Item> listParents = new ArrayList<Item>(1);
|
|
listParents.add(root);
|
|
// workspaceLogger.trace("returning: "+listParents.toString());
|
|
return listParents;
|
|
}
|
|
else{
|
|
logger.trace("returning empty list");
|
|
return new ArrayList<Item>(); // empty list
|
|
}
|
|
}
|
|
|
|
//WorkspaceItem lastItem = parents.get(parents.size()-1);
|
|
|
|
|
|
|
|
//Adding the item passed as last first parent
|
|
if(includeItemAsParent && wsItem.isFolder()) {
|
|
WorkspaceFolder wsItemAsFolder =(WorkspaceFolder) wsItem;
|
|
Item theItem = ItemBuilder.buildFolderForBreadcrumbs(wsItemAsFolder, null);
|
|
arrayParents.add(theItem);
|
|
}
|
|
|
|
/** HANDLE MY_SPECIAL_FOLDER TO AVOID COMPLETE PATH WORKSPACE/MY_SPECIAL_FOLDER
|
|
* BUT RETURNING ONLY /MY_SPECIAL_FOLDER
|
|
*/
|
|
|
|
WorkspaceItem theFirstParent = parents.get(0);
|
|
|
|
if(wsItem.isFolder()){
|
|
if(ItemBuilder.isSpecialFolder((WorkspaceFolder) wsItem, theFirstParent.isRoot())){
|
|
logger.debug("item id is special folder, returning");
|
|
return new ArrayList<Item>(arrayParents);
|
|
}
|
|
|
|
if(itemIdentifier.compareTo(parentLimit)==0){
|
|
logger.debug("item and parent limit are identical element, returning");
|
|
return new ArrayList<Item>(arrayParents);
|
|
}
|
|
|
|
}
|
|
|
|
//CONVERTING PATH
|
|
logger.debug("converting parents...");
|
|
//for (int i = parents.size()-2; i >= 0; i--) {
|
|
for (int i = 0; i<parents.size(); i++) {
|
|
logger.debug("converting index: "+i);
|
|
WorkspaceFolder wsParentFolder = (WorkspaceFolder) parents.get(i);
|
|
logger.debug("the folder at index: "+i +" is "+wsParentFolder.getName());
|
|
Item itemParent = ItemBuilder.buildFolderForBreadcrumbs(wsParentFolder, null);
|
|
arrayParents.add(itemParent);
|
|
if(itemParent.isSpecialFolder()){ //SKIP HOME PARENT FOR MY_SPECIAL_FOLDER
|
|
logger.info("arrayParents index "+i+" is special folder, break");
|
|
break;
|
|
}else if(parentLimit.compareTo(itemParent.getId())==0){
|
|
logger.info("reached parent limit "+parentLimit+", break");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//SET PARENTS
|
|
logger.debug("setting parents..");
|
|
for(int i=0; i<arrayParents.size()-1; i++){
|
|
|
|
Item parent = arrayParents.get(i+1);
|
|
Item fileModel = arrayParents.get(i);
|
|
|
|
if(fileModel!=null) {
|
|
fileModel.setParent(parent);
|
|
}
|
|
}
|
|
// if(arrayParents[0]==null){ //EXIT BY BREAK IN CASE OF SPECIAL FOLDER OR REACHED PARENT LIMIT
|
|
// List<Item> breadcrumbs = new ArrayList<Item>();
|
|
// for (int i=1; i<arrayParents.length; i++) {
|
|
// if(arrayParents[i]!=null) {
|
|
// breadcrumbs.add(arrayParents[i]);
|
|
// }
|
|
// }
|
|
// logger.debug("Returning the breadcrumb: "+breadcrumbs);
|
|
// return breadcrumbs;
|
|
// }
|
|
// else {
|
|
// return new ArrayList<Item>(Arrays.asList(arrayParents));
|
|
// }
|
|
|
|
Collections.reverse(arrayParents);
|
|
logger.info("Reversed the parent list");
|
|
|
|
if(logger.isDebugEnabled()) {
|
|
for (Item item : arrayParents) {
|
|
logger.info("Returning parent: "+item.getName());
|
|
}
|
|
}
|
|
// logger.info("Limited list of parents returning size: "+arrayParents.length);
|
|
return arrayParents;
|
|
//new ArrayList<Item>(Arrays.asList(arrayParents));
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error in get List Parents By Item Identifier ", e);
|
|
throw new Exception("Sorry, an error occurred during path retrieving!");
|
|
}
|
|
}
|
|
|
|
// /**
|
|
// * Gets the size by item id.
|
|
// *
|
|
// * @param itemId the item id
|
|
// * @return the size by item id
|
|
// * @throws Exception the exception
|
|
// */
|
|
// /* (non-Javadoc)
|
|
// * @see org.gcube.portlets.widgets.wsexplorer.client.rpc.WorkspaceExplorerService#loadSizeByItemId(java.lang.String)
|
|
// */
|
|
// @Override
|
|
// public Long getSizeByItemId(String itemId) throws Exception {
|
|
//
|
|
// logger.info("get Size By ItemId "+ itemId);
|
|
// try {
|
|
//
|
|
// Workspace workspace = getWorkspace();
|
|
// WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
// Long size = new Long(-1);
|
|
//
|
|
// if(wsItem instanceof FileItem){ //ITEM
|
|
// FileItem fileItem = (FileItem) wsItem;
|
|
// size = new Long(fileItem.getSize());
|
|
// } else if (wsItem instanceof WorkspaceFolder ){ //FOLDER
|
|
// WorkspaceFolder theFolder = (WorkspaceFolder) wsItem;
|
|
// //size = theFolder.getSize(); NOT SUPPORTED BY SHUB
|
|
// } else if (wsItem instanceof WorkspaceSharedFolder){ //SHARED FOLDER
|
|
// WorkspaceSharedFolder theFolder = (WorkspaceSharedFolder) wsItem;
|
|
// //size = theFolder.getSize(); NOT SUPPORTED BY SHUB
|
|
// }
|
|
// logger.info("returning size: " +size);
|
|
// return size;
|
|
//
|
|
// } catch (Exception e) {
|
|
// logger.error("get Size By ItemId ", e);
|
|
// throw new Exception(e.getMessage());
|
|
// }
|
|
// }
|
|
|
|
// /**
|
|
// * Gets the mime type.
|
|
// *
|
|
// * @param itemId the item id
|
|
// * @return the mime type
|
|
// * @throws Exception the exception
|
|
// */
|
|
// /* (non-Javadoc)
|
|
// * @see org.gcube.portlets.widgets.wsexplorer.client.rpc.WorkspaceExplorerService#getMimeType(java.lang.String)
|
|
// */
|
|
// @Override
|
|
// public String getMimeType(String itemId) throws Exception {
|
|
//
|
|
// logger.info("get MimeType By ItemId "+ itemId);
|
|
// try {
|
|
//
|
|
// Workspace workspace = getWorkspace();
|
|
// WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
//
|
|
// if(wsItem instanceof FileItem) {
|
|
// FileItem fileItem = (FileItem) wsItem;
|
|
// return fileItem.getMimeType();
|
|
// }else
|
|
// return null;
|
|
//
|
|
// } catch (Exception e) {
|
|
// logger.error("get MimeType By ItemId ", e);
|
|
// throw new Exception(e.getMessage());
|
|
// }
|
|
// }
|
|
|
|
|
|
// /**
|
|
// * Gets the user acl for folder id.
|
|
// *
|
|
// * @param folderId the folder id
|
|
// * @return the user acl for folder id
|
|
// * @throws Exception the exception
|
|
// */
|
|
// @Override
|
|
// public String getUserACLForFolderId(String folderId) throws Exception{
|
|
// try {
|
|
// logger.info("Get user ACL to FOLDER id: "+folderId);
|
|
// Workspace workspace = getWorkspace();
|
|
// WorkspaceItem wsItem = workspace.getItem(folderId);
|
|
//
|
|
// if(!isASharedFolder(wsItem, false)) {
|
|
// return "OWNER";
|
|
// }
|
|
// else {
|
|
// return wsItem.getACLUser().toString();
|
|
// }
|
|
// } catch (Exception e) {
|
|
// logger.error("Error in server get UserACLForFolderId", e);
|
|
// String error = "An error occurred when getting ACL rules for selected folder. "+e.getMessage();
|
|
// throw new Exception(error);
|
|
// }
|
|
// }
|
|
|
|
|
|
/**
|
|
* Checks if is a shared folder.
|
|
*
|
|
* @param item the item
|
|
* @param asRoot the as root
|
|
* @return true, if is a shared folder
|
|
*/
|
|
private boolean isASharedFolder(WorkspaceItem item, boolean asRoot) {
|
|
try {
|
|
|
|
if (item != null && item.isFolder() && item.isShared()) { // IS A SHARED SUB-FOLDER
|
|
if (asRoot) {
|
|
return item.getType().equals(WorkspaceItemType.SHARED_FOLDER); // IS ROOT?
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
} catch (Exception e) {
|
|
logger.error("Error in server isASharedFolder", e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// /**
|
|
// * Gets the readable size by item id.
|
|
// *
|
|
// * @param itemId the item id
|
|
// * @return the readable size by item id
|
|
// * @throws Exception the exception
|
|
// */
|
|
// /* (non-Javadoc)
|
|
// * @see org.gcube.portlets.widgets.wsexplorer.client.rpc.WorkspaceExplorerService#getFormattedSizeByItemId(java.lang.String, org.gcube.portlets.widgets.wsexplorer.shared.SizeFormatter)
|
|
// */
|
|
// @Override
|
|
// public String getReadableSizeByItemId(String itemId) throws Exception {
|
|
//
|
|
// try{
|
|
// logger.info("getFormattedSize ByItemId "+ itemId);
|
|
// long size = getSizeByItemId(itemId);
|
|
// return StringUtil.readableFileSize(size);
|
|
// } catch (Exception e) {
|
|
// logger.error("getFormattedSize By ItemId ", e);
|
|
// throw new Exception(e.getMessage());
|
|
// }
|
|
// }
|
|
|
|
// /**
|
|
// * Creates the folder.
|
|
// *
|
|
// * @param nameFolder the name folder
|
|
// * @param description the description
|
|
// * @param parentId the parent id
|
|
// * @return the item
|
|
// * @throws Exception the exception
|
|
// */
|
|
// /* (non-Javadoc)
|
|
// * @see org.gcube.portlets.user.workspaceexplorerapp.client.rpc.WorkspaceExplorerAppService#createFolder(java.lang.String, java.lang.String, java.lang.String)
|
|
// */
|
|
// @Override
|
|
// public Item createFolder(String nameFolder, String description, String parentId) throws Exception {
|
|
//
|
|
// logger.debug("creating folder: "+nameFolder +", parent id: "+parentId);
|
|
// throw new WorkspaceNavigatorServiceException("The method 'createFolder' is not implemented");
|
|
//
|
|
// /*try {
|
|
//
|
|
// if(parentId==null || parentId.isEmpty())
|
|
// throw new Exception("Parent id is null or empty");
|
|
//
|
|
// if(nameFolder == null)
|
|
// nameFolder = "Empty Folder";
|
|
//
|
|
// Workspace workspace = getWorkspace();
|
|
// WorkspaceFolder wsFolder = workspace.createFolder(nameFolder, description, parentId);
|
|
// List<ItemType> allTypes = Arrays.asList(ItemType.values());
|
|
//
|
|
// Item parent = null;
|
|
// try{
|
|
// String parentPath = wsFolder.getParent()!=null?wsFolder.getParent().getPath():"";
|
|
// parent = ItemBuilder.getItem(null, wsFolder.getParent(), parentPath, allTypes, null, false);
|
|
// }catch(Exception e){
|
|
// logger.error("Get parent thown an exception, is it the root id? "+parentId);
|
|
// }
|
|
//
|
|
// //TODO PATCH TO AVOID PROBLEM ON GETPATH. FOR EXAMPLE WHEN PARENT IS ROOT
|
|
// String itemPath = null;
|
|
// try{
|
|
// itemPath = wsFolder.getPath();
|
|
// }catch(Exception e){
|
|
// logger.error("Get path thown an exception, for id: "+wsFolder.getId());
|
|
// itemPath= wsFolder.isFolder()?workspace.getRoot().getPath()+"/"+wsFolder.getName():workspace.getRoot().getPath();
|
|
// }
|
|
//
|
|
// return ItemBuilder.getItem(parent, wsFolder, itemPath, allTypes, null, false);
|
|
//
|
|
// } catch(InsufficientPrivilegesException e){
|
|
// String error = "Insufficient Privileges to create the folder";
|
|
// logger.error(error, e);
|
|
// throw new Exception(error);
|
|
// } catch (ItemAlreadyExistException e) {
|
|
// String error = "An error occurred on creating folder, " +e.getMessage();
|
|
// logger.error(error, e);
|
|
// throw new Exception(error);
|
|
// } catch (Exception e) {
|
|
// String error = "An error occurred on the sever during creating folder. Try again";
|
|
// logger.error(error, e);
|
|
// throw new Exception(error);
|
|
// }*/
|
|
//
|
|
// }
|
|
|
|
|
|
/**
|
|
* Gets the public link for item id.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the public link for item id
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public String getPublicLinkForItemId(String itemId) throws Exception{
|
|
|
|
logger.trace("get Public Link For ItemId: "+ itemId);
|
|
try{
|
|
|
|
if(itemId==null)
|
|
throw new Exception("Sorry, the itemId is null. The public link for empty item is unavailable");
|
|
|
|
Workspace workspace = getWorkspace();
|
|
WorkspaceItem wsItem = workspace.getItem(itemId);
|
|
|
|
if(wsItem==null)
|
|
throw new Exception("Sorry, the workspace item is null. The public link for empty item is unavailable");
|
|
|
|
if(wsItem instanceof FileItem){
|
|
|
|
URL theURL = workspace.getPublicLinkForFile(wsItem.getId());
|
|
|
|
if(theURL==null)
|
|
throw new Exception("Sorry, the public link for "+wsItem.getName() +" is not available");
|
|
|
|
return theURL.toString();
|
|
|
|
}else{
|
|
logger.warn("ItemId: "+ itemId +" is not available, sent exception Public Link unavailable");
|
|
throw new Exception("Sorry, the Public Link for selected item is unavailable");
|
|
}
|
|
|
|
}catch (Exception e) {
|
|
logger.error("Error on getting public link for item: "+itemId, e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the valid id from encrypted.
|
|
*
|
|
* @param encodedFolderId the encrypted folder id
|
|
* @return the valid id from encrypted
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public String getFolderIdFromEncrypted(String encodedFolderId) throws Exception{
|
|
try{
|
|
String scope = WsUtil.getScope(this.getThreadLocalRequest().getSession());
|
|
ScopeProvider.instance.set(scope);
|
|
logger.info("Trying to decode encoded folder Id: "+encodedFolderId +" in the scope: "+scope);
|
|
String base64DecodedId = StringUtil.base64DecodeString(encodedFolderId);
|
|
// String useThis = "P+IpJ6F6cTaGENfKMQWmStGUE79gbri5bVGRnzOvb8YUNIsJqFrdhceBrF+/u00j";
|
|
logger.info("Base 64 decoded folder Id: "+base64DecodedId +", now decrypting...");
|
|
String decryptedFId = StringEncrypter.getEncrypter().decrypt(base64DecodedId);
|
|
logger.info("Decrypted folder Id: "+decryptedFId, " returning");
|
|
return decryptedFId;
|
|
}catch(Exception e){
|
|
logger.error("Error during decrypting folder Id: "+encodedFolderId,e);
|
|
throw new Exception("Sorry, an error occurred when decrypting the folder id. Try again or contact the support");
|
|
}
|
|
}
|
|
|
|
}
|