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.
299 lines
11 KiB
Java
299 lines
11 KiB
Java
package org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import org.gcube.common.homelibary.model.items.type.FolderItemType;
|
|
import org.gcube.common.homelibrary.home.HomeLibrary;
|
|
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
|
|
import org.gcube.common.homelibrary.home.workspace.Workspace;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
|
|
import org.gcube.common.homelibrary.home.workspace.catalogue.WorkspaceCatalogue;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalUrl;
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.GCubeItem;
|
|
import org.gcube.datacatalogue.ckanutillibrary.server.utils.UtilMethods;
|
|
import org.gcube.datacatalogue.ckanutillibrary.shared.ResourceBean;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.DatasetBean;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.ResourceElementBean;
|
|
|
|
import com.liferay.portal.kernel.log.Log;
|
|
import com.liferay.portal.kernel.log.LogFactoryUtil;
|
|
|
|
public class WorkspaceUtils {
|
|
|
|
//private static final org.slf4j.Logger logger = LoggerFactory.getLogger(WorkspaceUtils.class);
|
|
private static final Log logger = LogFactoryUtil.getLog(WorkspaceUtils.class);
|
|
private static final String RESOURCES_NAME_SEPARATOR = "_";
|
|
private static final String STRIP_NOT_ALPHANUMERIC = "[^A-Za-z0-9.-_]";
|
|
|
|
/**
|
|
* This method receives a folder id within the user's workspace and set the list of resources in the dataset bean to be returned
|
|
* @param folderId
|
|
* @param owner
|
|
* @param bean
|
|
* @param userName
|
|
* @throws Exception
|
|
*/
|
|
public static void handleWorkspaceResources(String folderId, String userName,
|
|
DatasetBean bean) throws Exception {
|
|
|
|
// get workspace
|
|
Workspace ws = HomeLibrary
|
|
.getHomeManagerFactory()
|
|
.getHomeManager()
|
|
.getHome().getWorkspace();
|
|
|
|
WorkspaceItem originalFolderOrFile = ws.getItem(folderId);
|
|
|
|
logger.debug("Item retrieved is " + originalFolderOrFile);
|
|
|
|
if(!originalFolderOrFile.isFolder()){
|
|
|
|
ResourceElementBean resource = new ResourceElementBean();
|
|
resource.setDescription(originalFolderOrFile.getDescription());
|
|
resource.setFolder(false);
|
|
resource.setEditableName(originalFolderOrFile.getName());
|
|
resource.setName(originalFolderOrFile.getName());
|
|
resource.setOriginalIdInWorkspace(folderId);
|
|
bean.setResourceRoot(resource);
|
|
bean.setTitle(originalFolderOrFile.getName().replaceAll(STRIP_NOT_ALPHANUMERIC, " "));
|
|
bean.setDescription(originalFolderOrFile.getDescription());
|
|
|
|
}else{
|
|
|
|
String onlyAlphanumericTitle = originalFolderOrFile.getName().replaceAll(STRIP_NOT_ALPHANUMERIC, " ");
|
|
bean.setTitle(onlyAlphanumericTitle);
|
|
bean.setDescription(originalFolderOrFile.getDescription());
|
|
|
|
// Create the folder in the catalogue
|
|
Map<String, String> folderItems = getGcubeItemProperties(originalFolderOrFile);
|
|
|
|
if(folderItems != null){
|
|
// transform this properties
|
|
Map<String, List<String>> tempItems = new HashMap<String, List<String>>(folderItems.size());
|
|
|
|
Iterator<Entry<String, String>> iterator = folderItems.entrySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
Map.Entry<java.lang.String, java.lang.String> entry = (Map.Entry<java.lang.String, java.lang.String>) iterator
|
|
.next();
|
|
tempItems.put(entry.getKey(), Arrays.asList(entry.getValue()));
|
|
}
|
|
bean.setCustomFields(tempItems);
|
|
}
|
|
|
|
// set them into the bean
|
|
bean.setResourceRoot(WorkspaceUtils.getTreeFromFolder(folderId, ws));
|
|
}
|
|
|
|
}
|
|
|
|
/** Gets the gcube item properties.
|
|
*
|
|
* @param item the item
|
|
* @return the gcube item properties
|
|
*/
|
|
public static Map<String, String> getGcubeItemProperties(WorkspaceItem item) {
|
|
|
|
if(item instanceof GCubeItem){
|
|
GCubeItem gItem = (GCubeItem) item;
|
|
try {
|
|
if(gItem.getProperties()!=null){
|
|
Map<String, String> map = gItem.getProperties().getProperties();
|
|
HashMap<String, String> properties = new HashMap<String, String>(map.size()); //TO PREVENT GWT SERIALIZATION ERROR
|
|
for (String key : map.keySet())
|
|
properties.put(key, map.get(key));
|
|
|
|
return properties;
|
|
}
|
|
} catch (InternalErrorException e) {
|
|
logger.error("Error in server getItemProperties: ", e);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns a tree object
|
|
* @param workspaceFolderId
|
|
* @param ws
|
|
* @return ResourceElementBean a tree object
|
|
* @throws Exception
|
|
*/
|
|
public static ResourceElementBean getTreeFromFolder(String workspaceFolderId, Workspace ws) throws Exception{
|
|
|
|
ResourceElementBean rootElem = new ResourceElementBean();
|
|
String pathSeparator = ws.getPathSeparator();
|
|
WorkspaceItem initialItem = ws.getItem(workspaceFolderId);
|
|
String fullPathBase = initialItem.getPath();
|
|
fullPathBase = fullPathBase.endsWith(ws.getPathSeparator()) ? fullPathBase : fullPathBase + ws.getPathSeparator();
|
|
rootElem.setFolder(initialItem.isFolder());
|
|
rootElem.setFullPath(initialItem.getPath().replace(fullPathBase, ""));
|
|
rootElem.setName(initialItem.getName());
|
|
rootElem.setOriginalIdInWorkspace(initialItem.getId());
|
|
rootElem.setDescription(initialItem.getDescription());
|
|
extractEditableNameFromPath(rootElem, pathSeparator);
|
|
|
|
// recursive visiting
|
|
if(initialItem.isFolder())
|
|
visit(rootElem, initialItem, fullPathBase, pathSeparator);
|
|
|
|
logger.debug("Tree that is going to be returned is " + rootElem);
|
|
return rootElem;
|
|
}
|
|
|
|
/**
|
|
* Recursive visit of a workspace item
|
|
* @param rootElem
|
|
* @param initialItemWS
|
|
* @throws InternalErrorException
|
|
*/
|
|
private static void visit(ResourceElementBean parent, WorkspaceItem initialItemWS, String fullPathBase, String pathSeparator) throws InternalErrorException {
|
|
List<? extends WorkspaceItem> children = initialItemWS.getChildren();
|
|
ArrayList<ResourceElementBean> childrenInTree = new ArrayList<ResourceElementBean>(children.size());
|
|
for (WorkspaceItem item : children) {
|
|
// logger.debug("Path BEFORE REPLACE is " + item.getPath());
|
|
// logger.debug("Path AFTER REPLACE is " + item.getPath().replace(fullPathBase, ""));
|
|
// logger.debug("Name is " + item.getName());
|
|
// logger.debug("id is " + item.getId());
|
|
ResourceElementBean elem = new ResourceElementBean();
|
|
elem.setFolder(item.isFolder());
|
|
elem.setOriginalIdInWorkspace(item.getId());
|
|
elem.setFullPath(item.getPath().replace(fullPathBase, ""));
|
|
elem.setParent(parent);
|
|
elem.setName(item.getName());
|
|
elem.setDescription(item.getDescription());
|
|
extractEditableNameFromPath(elem, pathSeparator);
|
|
childrenInTree.add(elem);
|
|
logger.trace("Elem is " + elem);
|
|
if(item.isFolder())
|
|
visit(elem, item, fullPathBase, pathSeparator);
|
|
}
|
|
// add these list as child of the rootElem
|
|
parent.setChildren(childrenInTree);
|
|
}
|
|
|
|
/**
|
|
* Replaces the "/" char with a custom one and return an editable name for the user
|
|
* @param rootElem
|
|
* @param pathSeparatorInWs
|
|
*/
|
|
private static void extractEditableNameFromPath(ResourceElementBean rootElem, String pathSeparatorInWs) {
|
|
|
|
if(rootElem == null)
|
|
return;
|
|
|
|
String elemName = rootElem.getName();
|
|
String fullPath = rootElem.getFullPath();
|
|
logger.info("Element original is " + rootElem);
|
|
|
|
int lastIndex = rootElem.getFullPath().lastIndexOf(elemName);
|
|
fullPath = rootElem.getFullPath().substring(0, lastIndex);
|
|
fullPath = fullPath.replaceAll(pathSeparatorInWs, RESOURCES_NAME_SEPARATOR) + elemName;
|
|
rootElem.setEditableName(fullPath);
|
|
}
|
|
|
|
/**
|
|
* Copy into the .catalogue area folder the checked resources.
|
|
* There is no difference among a single-file-publish and a folder-publish.
|
|
* @param folderId
|
|
* @param userName
|
|
* @param bean
|
|
* @return
|
|
*/
|
|
public static List<ResourceBean> copyResourcesToUserCatalogueArea(String folderOrFileId, String userName, DatasetBean bean) throws Exception{
|
|
|
|
logger.debug("Request to copy onto catalogue area....");
|
|
List<ResourceBean> resources = new ArrayList<ResourceBean>();
|
|
WorkspaceItem copiedFolder = null;
|
|
WorkspaceCatalogue userCatalogue = null;
|
|
ResourceElementBean rootResource = bean.getResourceRoot();
|
|
|
|
// into the .catalogue area of the user's workspace
|
|
Workspace ws = HomeLibrary
|
|
.getHomeManagerFactory()
|
|
.getHomeManager()
|
|
.getHome()
|
|
.getWorkspace();
|
|
|
|
// Retrieve the catalogue of the user
|
|
userCatalogue = ws.getCatalogue();
|
|
|
|
// get workspace item (it could be a file or a folder)
|
|
WorkspaceItem originalItem = ws.getItem(folderOrFileId);
|
|
|
|
// copy the folder in the catalogue if it is a folder, or create a new folder
|
|
long referenceTime = System.currentTimeMillis();
|
|
if(originalItem.isFolder()){
|
|
copiedFolder = userCatalogue.addWorkspaceItem(folderOrFileId, userCatalogue.getId()); // add to .catalogue root area
|
|
copiedFolder.setDescription(bean.getDescription());
|
|
((WorkspaceFolder)copiedFolder).rename(UtilMethods.fromProductTitleToName(bean.getTitle()) + "_" + referenceTime);
|
|
}
|
|
else{
|
|
copiedFolder = userCatalogue.createFolder(UtilMethods.fromProductTitleToName(bean.getTitle()) + "_" + referenceTime, bean.getDescription());
|
|
}
|
|
|
|
// retrieve the children
|
|
List<ResourceElementBean> resourcesToAdd = rootResource.getChildren();
|
|
|
|
// copy only the selected ones
|
|
for(ResourceElementBean resource : resourcesToAdd){
|
|
|
|
if (resource.isToBeAdded()) {
|
|
|
|
logger.debug("Resource to add is " + resource);
|
|
|
|
// ok it is a file, so copy it into the copiedFolder
|
|
WorkspaceItem copiedFile = userCatalogue.addWorkspaceItem(resource.getOriginalIdInWorkspace(), copiedFolder.getId());
|
|
|
|
// name and description could have been edited
|
|
copiedFile.setDescription(resource.getDescription());
|
|
|
|
// check if it is an external url
|
|
String externalUrl = null;
|
|
try{
|
|
boolean isExternalUrl = ((FolderItem)copiedFile).getFolderItemType().equals(FolderItemType.EXTERNAL_URL);
|
|
externalUrl = isExternalUrl ? ((ExternalUrl)copiedFile).getUrl() : null;
|
|
}catch(Exception e){
|
|
logger.warn("Unable to check if it is an external url file ", e);
|
|
}
|
|
|
|
resources.add(new ResourceBean(
|
|
externalUrl != null ? externalUrl : copiedFile.getPublicLink(true),
|
|
resource.getEditableName(),
|
|
copiedFile.getDescription(),
|
|
copiedFile.getId(),
|
|
userName,
|
|
null, // dataset id, to be set
|
|
((FolderItem)copiedFile).getMimeType()));
|
|
|
|
// postpone rename operation
|
|
copiedFile.rename(resource.getEditableName());
|
|
}
|
|
|
|
}
|
|
return resources;
|
|
}
|
|
|
|
// public static void main(String[] args) throws Exception {
|
|
//
|
|
// ScopeProvider.instance.set();
|
|
// SecurityTokenProvider.instance.set();
|
|
// String path = "/Workspace/DataMiner";
|
|
// Workspace ws = HomeLibrary
|
|
// .getHomeManagerFactory()
|
|
// .getHomeManager()
|
|
// .getHome()
|
|
// .getWorkspace();
|
|
// WorkspaceItem miner = ws.getItemByPath(path);
|
|
// handleWorkspaceResources(miner.getId(), "costantino.perciante", new DatasetBean());
|
|
//
|
|
// }
|
|
|
|
} |