458 lines
12 KiB
Java
458 lines
12 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.portlets.user.workspaceexplorerapp.server.workspace;
|
|
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceFolder;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceItem;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.WorkspaceSharedFolder;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.exceptions.InternalErrorException;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.items.FileItem;
|
|
import org.gcube.common.storagehubwrapper.shared.tohl.items.PropertyMap;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.client.Util;
|
|
import org.gcube.portlets.user.workspaceexplorerapp.client.WorkspaceExplorerAppConstants;
|
|
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.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
|
// TODO: Auto-generated Javadoc
|
|
/**
|
|
* The Class ItemBuilder.
|
|
*
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
|
|
* Feb 22, 2016
|
|
*/
|
|
public class ItemBuilder {
|
|
|
|
public static final Logger _log = LoggerFactory.getLogger(ItemBuilder.class);
|
|
/**
|
|
* Purge empty folders.
|
|
*
|
|
* @param item the item
|
|
* @return the item
|
|
*/
|
|
public static Item purgeEmptyFolders(Item item)
|
|
{
|
|
//for (Item child:item.getChildren()) purgeEmptyFolders(child); ONLY FIRST LEVEL
|
|
|
|
List<Item> toRemoveList = new LinkedList<Item>();
|
|
for (Item child:item.getChildren()) {
|
|
boolean toRemove = isAnEmptyFolder(child);
|
|
if (toRemove) {
|
|
toRemoveList.add(child);
|
|
}
|
|
}
|
|
for (Item child:toRemoveList) {
|
|
item.removeChild(child);
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks if is an empty folder.
|
|
*
|
|
* @param item the item
|
|
* @return true, if is an empty folder
|
|
*/
|
|
protected static boolean isAnEmptyFolder(Item item)
|
|
{
|
|
return Util.isFolder(item.getType()) && item.getChildren().size() == 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the item.
|
|
*
|
|
* @param parent the parent
|
|
* @param workspaceItem the workspace item
|
|
* @param workspaceItemPath the workspace item path
|
|
* @param showableTypes the showable types
|
|
* @param filterCriteria the filter criteria
|
|
* @param loadChildren the load children
|
|
* @return the item
|
|
* @throws InternalErrorException the internal error exception
|
|
*/
|
|
public static Item getItem(Item parent, WorkspaceItem workspaceItem, String workspaceItemPath, List<ItemType> showableTypes, FilterCriteria filterCriteria) throws Exception
|
|
{
|
|
|
|
try {
|
|
|
|
String itemName = workspaceItem.getName();
|
|
boolean isFolder = workspaceItem.isFolder();
|
|
ItemType type = getItemType(workspaceItem);
|
|
|
|
if (!showableTypes.contains(type)) {
|
|
return null;
|
|
}
|
|
if (!filterItem(workspaceItem, filterCriteria)) {
|
|
return null;
|
|
}
|
|
|
|
boolean isSharedFolder = false;
|
|
if(workspaceItem instanceof WorkspaceSharedFolder){
|
|
isSharedFolder = true;
|
|
_log.debug("Is shared folder");
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) workspaceItem;
|
|
//itemName = shared.isVreFolder()?shared.getDisplayName():workspaceItem.getName(); //NOT IMPLEMENTED BY SHUB
|
|
itemName = shared.isVreFolder()?shared.getName():workspaceItem.getName();
|
|
}
|
|
|
|
// _log.debug("Building Item for: "+itemName);
|
|
Item item = null;
|
|
try{
|
|
|
|
item = new Item(parent,
|
|
workspaceItem.getId(),
|
|
itemName,
|
|
type,
|
|
workspaceItemPath,
|
|
workspaceItem.getOwner(),
|
|
toDate(workspaceItem.getCreationTime()),
|
|
isFolder,
|
|
false);
|
|
|
|
item.setSharedFolder(isSharedFolder);
|
|
}catch(Exception e){
|
|
_log.error("Error on getting item: "+itemName+" with id: "+workspaceItem.getId()+", from HL, so skipping item");
|
|
return null;
|
|
}
|
|
|
|
// if(loadChildren){
|
|
// //TODO A PATCH TO AVOID A SLOW GETPATH
|
|
// // workspaceItemPath = workspaceItem.getPath();
|
|
// for (WorkspaceItem child: workspaceItem.getChildren()){
|
|
// String itemPath = workspaceItemPath;
|
|
// if(child.isFolder())
|
|
// itemPath+="/"+child.getName();
|
|
//
|
|
// // _log.trace("\nConverting child item: "+child.getName());
|
|
// Item itemChild = getItem(item, child, itemPath, showableTypes, filterCriteria, false);
|
|
// // _log.trace("Item: "+child.getName() +" converted!!!");
|
|
// if (itemChild!=null){
|
|
// item.addChild(itemChild);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
return item;
|
|
}catch (Exception e) {
|
|
_log.error("Error on getting item: "+workspaceItem.getName()+" with id: "+workspaceItem.getId(), e);
|
|
throw new Exception("Error on retrieving the item: "+workspaceItem.getName());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds the children.
|
|
*
|
|
* @param item the item
|
|
* @param itemPathBuilt the item path built
|
|
* @param children the children
|
|
* @param showableTypes the showable types
|
|
* @param filterCriteria the filter criteria
|
|
* @return the item with the children added
|
|
* @throws Exception the exception
|
|
*/
|
|
public static Item addChildren(Item item, String itemPathBuilt, List<? extends WorkspaceItem> children, List<ItemType> showableTypes, FilterCriteria filterCriteria) throws Exception {
|
|
|
|
if(item==null)
|
|
return null;
|
|
|
|
if(children==null)
|
|
return item;
|
|
|
|
for (WorkspaceItem child: children){
|
|
String itemPath = itemPathBuilt;
|
|
if(child.isFolder()) {
|
|
itemPath+="/"+child.getName();
|
|
}
|
|
|
|
Item itemChild = getItem(item, child, itemPath, showableTypes, filterCriteria);
|
|
// _log.trace("Item: "+child.getName() +" converted!!!");
|
|
if (itemChild!=null){
|
|
item.addChild(itemChild);
|
|
}
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
|
|
/**
|
|
* To date.
|
|
*
|
|
* @param calendar the calendar
|
|
* @return the date
|
|
*/
|
|
public static Date toDate(Calendar calendar)
|
|
{
|
|
if (calendar == null) return null;
|
|
return calendar.getTime();
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the item type.
|
|
*
|
|
* @param item the item
|
|
* @return the item type
|
|
*/
|
|
protected static ItemType getItemType(WorkspaceItem item) {
|
|
switch (item.getType()) {
|
|
case SHARED_FOLDER:
|
|
case FOLDER: {
|
|
return ItemType.FOLDER;
|
|
}
|
|
case FILE_ITEM:
|
|
|
|
if (item instanceof FileItem)
|
|
|
|
return getFileItemType((FileItem) item);
|
|
|
|
else
|
|
return ItemType.UNKNOWN_TYPE;
|
|
case URL_ITEM:
|
|
return ItemType.URL_DOCUMENT;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the file item type.
|
|
*
|
|
* @param item the item
|
|
* @return the file item type
|
|
*/
|
|
protected static ItemType getFileItemType(FileItem item){
|
|
|
|
try{
|
|
return ItemType.valueOf(item.getFileItemType().toString());
|
|
}catch (Exception e) {
|
|
_log.error("Item Type non found: ",e);
|
|
return ItemType.UNKNOWN_TYPE;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Filter item using the input Filter Criteria
|
|
*
|
|
* @param item the item
|
|
* @param filterCriteria the filter criteria
|
|
* @return true, if successful
|
|
*/
|
|
protected static boolean filterItem(WorkspaceItem item, FilterCriteria filterCriteria) {
|
|
if(filterCriteria==null) {
|
|
return true;
|
|
}
|
|
|
|
boolean mimeTypeCheck = checkAllowedMimeTypes(item, filterCriteria.getAllowedMimeTypes());
|
|
if (!mimeTypeCheck) {
|
|
return false;
|
|
}
|
|
|
|
boolean fileExtensionCheck = checkAllowedFileExtension(item, filterCriteria.getAllowedFileExtensions());
|
|
if(!fileExtensionCheck) {
|
|
return false;
|
|
}
|
|
|
|
boolean propertiesCheck = checkProperties(item, filterCriteria.getRequiredProperties());
|
|
|
|
return propertiesCheck;
|
|
}
|
|
|
|
/**
|
|
* Check allowed mime types on file.
|
|
*
|
|
* @param item the item
|
|
* @param allowedMimeTypes the allowed mime types
|
|
* @return true, if successful
|
|
*/
|
|
protected static boolean checkAllowedMimeTypes(WorkspaceItem item, List<String> allowedMimeTypes){
|
|
if (allowedMimeTypes==null || allowedMimeTypes.size()==0) {
|
|
return true;
|
|
}
|
|
|
|
if (item instanceof FileItem) {
|
|
FileItem fileItem = (FileItem) item;
|
|
String mimeType = fileItem.getMimeType();
|
|
return allowedMimeTypes.contains(mimeType);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Check allowed file extension on file.
|
|
*
|
|
* @param item the item
|
|
* @param allowedFileExtension the allowed mime types
|
|
* @return true, if successful
|
|
*/
|
|
protected static boolean checkAllowedFileExtension(WorkspaceItem item, List<String> allowedFileExtension){
|
|
if (allowedFileExtension==null || allowedFileExtension.size()==0) {
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
if (item instanceof FileItem) {
|
|
String name = item.getName();
|
|
return checkFileExtension(name, allowedFileExtension);
|
|
}
|
|
return true;
|
|
} catch (Exception e) {
|
|
_log.error("checkAllowedFileExtension, InternalErrorException: ",e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check file extension.
|
|
*
|
|
* @param fileName the file name
|
|
* @param allowedFileExtension the allowed file extension
|
|
* @return true, if successful
|
|
*/
|
|
protected static boolean checkFileExtension(String fileName, List<String> allowedFileExtension){
|
|
|
|
if(fileName==null || fileName.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
int dot = fileName.lastIndexOf(".");
|
|
if(dot>=0 && dot+1<=fileName.length()){
|
|
|
|
String ext = fileName.substring(dot+1, fileName.length());
|
|
_log.trace("Extension found: "+ext +" for: "+fileName);
|
|
// if(ext.isEmpty())
|
|
// return false;
|
|
for (String fe : allowedFileExtension) {
|
|
if(ext.compareTo(fe)==0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
_log.trace("Extension not found for: "+fileName);
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Check properties.
|
|
*
|
|
* @param item the item
|
|
* @param requestedProperties the requested properties
|
|
* @return true, if successful
|
|
*/
|
|
protected static boolean checkProperties(WorkspaceItem item, Map<String, String> requestedProperties) {
|
|
|
|
if (requestedProperties == null || requestedProperties.size() == 0) {
|
|
return true;
|
|
}
|
|
|
|
if (item.getPropertyMap() != null) {
|
|
PropertyMap mapProp = item.getPropertyMap();
|
|
if (mapProp != null && mapProp.getValues() != null) {
|
|
Map<String, Object> itemProperties = mapProp.getValues();
|
|
for (Entry<String, String> requestProperty : requestedProperties.entrySet()) {
|
|
Object propertyValue = itemProperties.get(requestProperty.getKey());
|
|
if (propertyValue == null) {
|
|
return false;
|
|
}
|
|
if (!propertyValue.equals(requestProperty.getValue())) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Builds the folder to breadcrumbs.
|
|
*
|
|
* @param wsFolder the ws folder
|
|
* @param parent the parent
|
|
* @return the item
|
|
* @throws InternalErrorException the internal error exception
|
|
*/
|
|
public static Item buildFolderForBreadcrumbs(WorkspaceFolder wsFolder, Item parent) throws Exception {
|
|
|
|
String name = "";
|
|
boolean isSpecialFolder = false;
|
|
boolean isRoot = false;
|
|
|
|
if(wsFolder.isRoot()){ //IS ROOT
|
|
name = WorkspaceExplorerAppConstants.HOME_LABEL;
|
|
isRoot = true;
|
|
}else if(wsFolder.isShared() && wsFolder instanceof WorkspaceSharedFolder){
|
|
//MANAGEMENT SHARED FOLDER NAME
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) wsFolder;
|
|
//name = shared.isVreFolder()?shared.getDisplayName():wsFolder.getName();
|
|
name = shared.isVreFolder()?shared.getName():wsFolder.getName(); //not implemented by SHUB
|
|
|
|
}else if(parent!=null && isSpecialFolder(wsFolder, parent.isRoot())){
|
|
//MANAGEMENT SPECIAL FOLDER
|
|
name = WorkspaceExplorerAppConstants.VRE_FOLDERS_LABEL;
|
|
isSpecialFolder = true;
|
|
}
|
|
else {
|
|
name = wsFolder.getName();
|
|
}
|
|
|
|
//BUILDS A SIMPLE ITEM FOR BREADCRUMB
|
|
String path = null; //wsFolder.getPath(); FORCED TO NULL BECAUSE IS SLOW CALL
|
|
Item item = new Item(null, wsFolder.getId(), name, ItemType.FOLDER, path, null, null, true, isRoot);
|
|
item.setSpecialFolder(isSpecialFolder);
|
|
|
|
_log.debug("breadcrumb returning: "+item);
|
|
return item;
|
|
}
|
|
|
|
/**
|
|
* Checks if is special folder.
|
|
*
|
|
* @param wsFolder the ws folder
|
|
* @return true, if is special folder
|
|
*/
|
|
public static boolean isSpecialFolder(WorkspaceFolder wsFolder, boolean parentIsRoot){
|
|
|
|
try {
|
|
return wsFolder.getName().compareTo(WorkspaceExplorerAppConstants.SPECIAL_FOLDERS_NAME)==0 && wsFolder.getParentId()!=null && parentIsRoot;
|
|
} catch (Exception e) {
|
|
_log.warn("isSpecialFolder exception, returning false");
|
|
return false;
|
|
}
|
|
}
|
|
/*
|
|
public static void main(String[] args) {
|
|
List<String> allowedFileExtension = new ArrayList<String>();
|
|
allowedFileExtension.add("csv");
|
|
allowedFileExtension.add("");
|
|
|
|
String fileName = "t";
|
|
System.out.println(checkFileExtension(fileName, allowedFileExtension));
|
|
}*/
|
|
}
|