2013-02-06 15:40:17 +01:00
|
|
|
package org.gcube.portlets.user.workspace.server;
|
|
|
|
|
2014-10-31 17:27:52 +01:00
|
|
|
import java.text.DecimalFormat;
|
2013-02-06 15:40:17 +01:00
|
|
|
import java.text.ParseException;
|
|
|
|
import java.text.SimpleDateFormat;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Calendar;
|
|
|
|
import java.util.Date;
|
2013-03-12 18:45:57 +01:00
|
|
|
import java.util.HashMap;
|
2013-02-06 15:40:17 +01:00
|
|
|
import java.util.LinkedHashMap;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Map.Entry;
|
|
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
|
2013-10-04 13:58:07 +02:00
|
|
|
import org.apache.log4j.Logger;
|
2015-05-20 18:39:49 +02:00
|
|
|
import org.gcube.common.homelibary.model.items.gcube.DocumentAlternativeLink;
|
|
|
|
import org.gcube.common.homelibary.model.items.gcube.DocumentMetadata;
|
|
|
|
import org.gcube.common.homelibary.model.items.gcube.DocumentPartLink;
|
|
|
|
import org.gcube.common.homelibary.model.items.type.NodeProperty;
|
|
|
|
import org.gcube.common.homelibary.model.items.type.WorkspaceItemType;
|
2013-09-27 17:39:28 +02:00
|
|
|
import org.gcube.common.homelibrary.home.User;
|
|
|
|
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.Properties;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
|
2014-02-13 15:19:42 +01:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceSharedFolder;
|
2013-09-27 17:39:28 +02:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.WorkspaceSmartFolder;
|
2014-02-17 15:56:42 +01:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.accessmanager.ACLType;
|
2013-09-27 17:39:28 +02:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntry;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryAdd;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryCreate;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryCut;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryPaste;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryRead;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryRemoval;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryRenaming;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryShare;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryUnshare;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.accounting.AccountingEntryUpdate;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderBulkCreator;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalFile;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalImage;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalPDFFile;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.ExternalUrl;
|
2014-11-04 18:20:06 +01:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.folder.items.GCubeItem;
|
2013-09-27 17:39:28 +02:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.search.SearchFolderItem;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.search.SearchItem;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.sharing.WorkspaceMessage;
|
2014-02-17 15:56:42 +01:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.trash.WorkspaceTrashFolder;
|
|
|
|
import org.gcube.common.homelibrary.home.workspace.trash.WorkspaceTrashItem;
|
2014-03-10 17:33:33 +01:00
|
|
|
import org.gcube.common.homelibrary.home.workspace.usermanager.GCubeGroup;
|
2014-02-17 15:56:42 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.ConstantsExplorer;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.GXTCategoryItemInterface;
|
|
|
|
import org.gcube.portlets.user.workspace.client.interfaces.GXTFolderItemTypeEnum;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.BulkCreatorModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.FileDetailsModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.FileGridModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.FileModel;
|
2014-02-17 15:56:42 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.model.FileTrashedModel;
|
2013-02-06 15:40:17 +01:00
|
|
|
import org.gcube.portlets.user.workspace.client.model.FolderGridModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.FolderModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.InfoContactModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.MessageModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.ScopeModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.model.SmartFolderModel;
|
|
|
|
import org.gcube.portlets.user.workspace.client.util.ImageRequestType;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTProperties;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceFolder;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceItem;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.GWTWorkspaceItemAction;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.GWTExternalImage;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.GWTExternalUrl;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.gcube.GWTDocumentMetadata;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.gcube.GWTImageDocument;
|
|
|
|
import org.gcube.portlets.user.workspace.client.workspace.folder.item.gcube.GWTUrlDocument;
|
2013-03-11 16:37:10 +01:00
|
|
|
import org.gcube.portlets.user.workspace.server.util.UserUtil;
|
2013-06-13 18:44:46 +02:00
|
|
|
import org.gcube.portlets.user.workspace.server.util.WsUtil;
|
2014-02-17 15:56:42 +01:00
|
|
|
import org.gcube.portlets.user.workspace.shared.WorkspaceACL;
|
|
|
|
import org.gcube.portlets.user.workspace.shared.WorkspaceACL.USER_TYPE;
|
2013-05-23 19:03:43 +02:00
|
|
|
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingEntryType;
|
2013-05-27 12:22:02 +02:00
|
|
|
import org.gcube.portlets.user.workspace.shared.accounting.GxtAccountingField;
|
2013-10-02 15:39:39 +02:00
|
|
|
import org.gcube.vomanagement.usermanagement.model.UserModel;
|
|
|
|
|
2015-05-25 18:05:12 +02:00
|
|
|
import com.google.gwt.user.client.Random;
|
2015-05-20 18:39:49 +02:00
|
|
|
import com.thoughtworks.xstream.XStream;
|
|
|
|
|
2013-03-11 19:06:56 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
|
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public class GWTWorkspaceBuilder {
|
|
|
|
|
|
|
|
protected static final String IMAGE_SERVICE_URL = "ImageService";
|
2013-10-04 13:58:07 +02:00
|
|
|
protected static Logger logger = Logger.getLogger(GWTWorkspaceBuilder.class);
|
2013-09-03 15:49:22 +02:00
|
|
|
private InfoContactModel userLogged;
|
2013-03-11 19:06:56 +01:00
|
|
|
protected static HashMap<String, InfoContactModel> hashTestUser = null;
|
2013-02-06 15:40:17 +01:00
|
|
|
// private final String UNKNOWN = "unknown";
|
|
|
|
// private final String FOLDER = "Folder";
|
|
|
|
|
|
|
|
|
2013-03-11 19:06:56 +01:00
|
|
|
|
2013-05-27 18:25:10 +02:00
|
|
|
/**
|
|
|
|
* @param logger
|
|
|
|
*/
|
|
|
|
public GWTWorkspaceBuilder() {
|
|
|
|
}
|
|
|
|
|
2013-03-11 19:06:56 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Used in test mode
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public static HashMap<String, InfoContactModel> getHashTestUsers(){
|
|
|
|
|
|
|
|
if(hashTestUser==null){
|
|
|
|
hashTestUser = new HashMap<String, InfoContactModel>();
|
2014-05-09 17:48:30 +02:00
|
|
|
|
|
|
|
//USERS
|
2014-03-10 17:33:33 +01:00
|
|
|
hashTestUser.put("federico.defaveri", new InfoContactModel("federico.defaveri", "federico.defaveri", "Federico de Faveri",false));
|
|
|
|
hashTestUser.put("antonio.gioia", new InfoContactModel("antonio.gioia", "antonio.gioia", "Antonio Gioia",false));
|
|
|
|
hashTestUser.put("fabio.sinibaldi", new InfoContactModel("fabio.sinibaldi", "fabio.sinibaldi", "Fabio Sinibaldi",false));
|
|
|
|
hashTestUser.put("pasquale.pagano", new InfoContactModel("pasquale.pagano", "pasquale.pagano", "Pasquale Pagano",false));
|
|
|
|
hashTestUser.put("valentina.marioli", new InfoContactModel("valentina.marioli", "valentina.marioli", "Valentina Marioli",false));
|
|
|
|
hashTestUser.put("roberto.cirillo", new InfoContactModel("roberto.cirillo", "roberto.cirillo", "Roberto Cirillo",false));
|
|
|
|
hashTestUser.put(WsUtil.TEST_USER.toString(), new InfoContactModel(WsUtil.TEST_USER, WsUtil.TEST_USER, WsUtil.TEST_USER_FULL_NAME,false));
|
|
|
|
hashTestUser.put("francesco.mangiacrapa", new InfoContactModel("francesco.mangiacrapa", "francesco.mangiacrapa", "Francesco Mangiacrapa",false));
|
|
|
|
hashTestUser.put("massimiliano.assante", new InfoContactModel("massimiliano.assante", "massimiliano.assante", "Massimiliano Assante",false));
|
2014-05-09 17:48:30 +02:00
|
|
|
|
|
|
|
//GROUPS
|
2014-05-29 12:44:34 +02:00
|
|
|
// hashTestUser.put("/gcube/devsec/devVRE", new InfoContactModel("/gcube/devsec/devVRE", "/gcube/devsec/devVRE", "",true));
|
|
|
|
// hashTestUser.put("/gcube/devsec/gcube-test-test", new InfoContactModel("/gcube/devsec/gcube-test-test", "/gcube/gcube-test-test", "",true));
|
2013-03-11 19:06:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return hashTestUser;
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
protected Date toDate(Calendar calendar)
|
|
|
|
{
|
|
|
|
if (calendar == null) return new Date(0);
|
|
|
|
return calendar.getTime();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
protected String toDateFormatToString(Calendar calendar){
|
|
|
|
|
|
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM, yyyy HH:mm:ss z");
|
|
|
|
|
|
|
|
Date resultdate = getDate(calendar);
|
|
|
|
|
|
|
|
return dateFormat.format(resultdate);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
protected Date toDateFormat(Calendar calendar){
|
|
|
|
|
|
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM, yyyy HH:mm:ss z");
|
|
|
|
|
|
|
|
Date resultdate = getDate(calendar);
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
resultdate = dateFormat.parse(dateFormat.format(resultdate));
|
|
|
|
|
|
|
|
} catch (ParseException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
resultdate = new Date(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return resultdate;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private Date getDate(Calendar calendar) {
|
|
|
|
|
|
|
|
Date resultdate = null;
|
|
|
|
|
|
|
|
if (calendar == null)
|
|
|
|
resultdate = new Date(0);
|
|
|
|
else
|
|
|
|
resultdate = new Date(calendar.getTimeInMillis());
|
|
|
|
|
|
|
|
return resultdate;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
protected GWTProperties buildGWTProperties(Properties metadata) throws InternalErrorException
|
|
|
|
{
|
|
|
|
//FIXME temp solution
|
2015-05-20 18:39:49 +02:00
|
|
|
// GWTProperties gwtProperties = new GWTProperties(metadata.getId(), metadata.getProperties());
|
2013-02-06 15:40:17 +01:00
|
|
|
return new GWTProperties();
|
|
|
|
}
|
|
|
|
|
2013-02-12 17:17:15 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
protected String buildImageUrl(String id)
|
|
|
|
{
|
|
|
|
return buildImageServiceUrl(id, ImageRequestType.IMAGE);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected String buildThumbnailUrl(String id)
|
|
|
|
{
|
|
|
|
return buildImageServiceUrl(id, ImageRequestType.THUMBNAIL);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected String buildImageServiceUrl(String id, ImageRequestType requestType){
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.append(IMAGE_SERVICE_URL);
|
|
|
|
sb.append("?id=");
|
|
|
|
sb.append(id);
|
|
|
|
sb.append("&type=");
|
|
|
|
sb.append(requestType.toString());
|
2015-05-25 18:05:12 +02:00
|
|
|
sb.append("&random=");
|
|
|
|
sb.append(Random.nextInt()+""+Random.nextInt()+""+Random.nextInt());
|
2013-02-06 15:40:17 +01:00
|
|
|
return sb.toString();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-20 18:39:49 +02:00
|
|
|
// protected GWTExternalFile buildGWTExternalFile(ExternalFile file, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(file.getProperties());
|
|
|
|
// GWTExternalFile gwtFile = new GWTExternalFile(
|
|
|
|
// toDate(file.getCreationTime()),
|
|
|
|
// file.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// file.getName(),
|
|
|
|
// file.getOwner().getPortalLogin(),
|
|
|
|
// file.getDescription(),
|
|
|
|
// toDate(file.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(file.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// file.getLength(),
|
|
|
|
// file.getMimeType());
|
|
|
|
//
|
|
|
|
// return gwtFile;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTExternalPDFFile buildGWTExternalPDFFile(ExternalPDFFile pdfFile, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(pdfFile.getProperties());
|
|
|
|
// GWTExternalPDFFile gwtPDFFile = new GWTExternalPDFFile(
|
|
|
|
// toDate(pdfFile.getCreationTime()),
|
|
|
|
// pdfFile.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// pdfFile.getName(),
|
|
|
|
// pdfFile.getOwner().getPortalLogin(),
|
|
|
|
// pdfFile.getDescription(),
|
|
|
|
// toDate(pdfFile.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(pdfFile.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// pdfFile.getLength(),
|
|
|
|
// pdfFile.getMimeType(),
|
|
|
|
// pdfFile.getAuthor(),
|
|
|
|
// pdfFile.getNumberOfPages(),
|
|
|
|
// pdfFile.getProducer(),
|
|
|
|
// pdfFile.getTitle(),
|
|
|
|
// pdfFile.getVersion());
|
|
|
|
//
|
|
|
|
// return gwtPDFFile;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTExternalImage buildGWTExternalImage(ExternalImage image, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(image.getProperties());
|
|
|
|
// GWTExternalImage gwtImage = new GWTExternalImage(
|
|
|
|
// toDate(image.getCreationTime()),
|
|
|
|
// image.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// image.getName(),
|
|
|
|
// image.getOwner().getPortalLogin(),
|
|
|
|
// image.getDescription(),
|
|
|
|
// toDate(image.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(image.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// buildImageUrl(image.getId()),
|
|
|
|
// buildThumbnailUrl(image.getId()),
|
|
|
|
// image.getWidth(),
|
|
|
|
// image.getHeight(),
|
|
|
|
// image.getLength(),
|
|
|
|
// image.getThumbnailWidth(),
|
|
|
|
// image.getThumbnailHeight(),
|
|
|
|
// image.getThumbnailLength(),
|
|
|
|
// image.getMimeType());
|
|
|
|
//
|
|
|
|
// return gwtImage;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTQuery buildGWTQuery(Query query, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(query.getProperties());
|
|
|
|
// GWTQuery gwtQuery = new GWTQuery(
|
|
|
|
// query.getId(),
|
|
|
|
// query.getName(),
|
|
|
|
// query.getDescription(),
|
|
|
|
// query.getOwner().getPortalLogin(),
|
|
|
|
// toDate(query.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(query.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(query.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// query.getLength());
|
|
|
|
//
|
|
|
|
// return gwtQuery;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTAquaMapsItem buildGWTAquaMapsItem(AquaMapsItem aquamapsItem, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(aquamapsItem.getProperties());
|
|
|
|
//
|
|
|
|
// GWTAquaMapsItem gwtAquaMapsItem = new GWTAquaMapsItem(
|
|
|
|
// aquamapsItem.getId(),
|
|
|
|
// aquamapsItem.getName(),
|
|
|
|
// aquamapsItem.getDescription(),
|
|
|
|
// aquamapsItem.getOwner().getPortalLogin(),
|
|
|
|
// toDate(aquamapsItem.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(aquamapsItem.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(aquamapsItem.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// aquamapsItem.getLength(),
|
|
|
|
// aquamapsItem.getMapName(),
|
|
|
|
// aquamapsItem.getMapType(),
|
|
|
|
// aquamapsItem.getAuthor(),
|
|
|
|
// aquamapsItem.getNumberOfSpecies(),
|
|
|
|
// aquamapsItem.getBoundingBox(),
|
|
|
|
// aquamapsItem.getPsoThreshold(),
|
|
|
|
// aquamapsItem.getNumberOfGeneratedImages()
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtAquaMapsItem;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// protected GWTTimeSeries buildGWTTimeSeries(TimeSeries timeseries, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(timeseries.getProperties());
|
|
|
|
//
|
|
|
|
// TimeSeriesInfo timeSeriesInfo = timeseries.getTimeSeriesInfo();
|
|
|
|
//
|
|
|
|
// GWTTimeSeries gwtTimeSeries = new GWTTimeSeries(
|
|
|
|
// timeseries.getId(),
|
|
|
|
// timeseries.getName(),
|
|
|
|
// timeseries.getDescription(),
|
|
|
|
// timeseries.getOwner().getPortalLogin(),
|
|
|
|
// toDate(timeseries.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(timeseries.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(timeseries.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// timeseries.getLength(),
|
|
|
|
// timeSeriesInfo.getId(),
|
|
|
|
// timeSeriesInfo.getTitle(),
|
|
|
|
// timeSeriesInfo.getCreator(),
|
|
|
|
// timeSeriesInfo.getDescription(),
|
|
|
|
// timeSeriesInfo.getCreationDate(),
|
|
|
|
// timeSeriesInfo.getPublisher(),
|
|
|
|
// timeSeriesInfo.getSourceId(),
|
|
|
|
// timeSeriesInfo.getSourceName(),
|
|
|
|
// timeSeriesInfo.getRights(),
|
|
|
|
// timeSeriesInfo.getDimension(),
|
|
|
|
// new LinkedList<String>(timeseries.getHeaderLabels())
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtTimeSeries;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTReportTemplate buildGWTReportTemplate(ReportTemplate template, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(template.getProperties());
|
|
|
|
// GWTReportTemplate gwtTemplate = new GWTReportTemplate(
|
|
|
|
// template.getId(),
|
|
|
|
// template.getName(),
|
|
|
|
// template.getDescription(),
|
|
|
|
// template.getOwner().getPortalLogin(),
|
|
|
|
// toDate(template.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(template.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(template.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// template.getLength(),
|
|
|
|
// toDate(template.getCreated()),
|
|
|
|
// toDate(template.getLastEdit()),
|
|
|
|
// template.getAuthor(),
|
|
|
|
// template.getLastEditBy(),
|
|
|
|
// template.getNumberOfSections(),
|
|
|
|
// template.getStatus());
|
|
|
|
//
|
|
|
|
// return gwtTemplate;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTReport buildGWTReport(Report template, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(template.getProperties());
|
|
|
|
// GWTReport gwtReport = new GWTReport(
|
|
|
|
// template.getId(),
|
|
|
|
// template.getName(),
|
|
|
|
// template.getDescription(),
|
|
|
|
// template.getOwner().getPortalLogin(),
|
|
|
|
// toDate(template.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(template.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(template.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// template.getLength(),
|
|
|
|
// toDate(template.getCreated()),
|
|
|
|
// toDate(template.getLastEdit()),
|
|
|
|
// template.getAuthor(),
|
|
|
|
// template.getLastEditBy(),
|
|
|
|
// template.getTemplateName(),
|
|
|
|
// template.getNumberOfSections(),
|
|
|
|
// template.getStatus()
|
|
|
|
// );
|
|
|
|
// return gwtReport;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTWorkflowReport buildGWTWorkflowReport(WorkflowReport workflowReport, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(workflowReport.getProperties());
|
|
|
|
// GWTWorkflowReport gwtWorkflowReport = new GWTWorkflowReport(
|
|
|
|
// workflowReport.getId(),
|
|
|
|
// workflowReport.getName(),
|
|
|
|
// workflowReport.getDescription(),
|
|
|
|
// workflowReport.getOwner().getPortalLogin(),
|
|
|
|
// toDate(workflowReport.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(workflowReport.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(workflowReport.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// workflowReport.getLength()
|
|
|
|
// );
|
|
|
|
// gwtWorkflowReport.setWorkflowStatus(workflowReport.getWorkflowStatus());
|
|
|
|
// return gwtWorkflowReport;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTWorkflowTemplate buildGWTWorkflowTemplate(WorkflowTemplate workflowTemplate, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(workflowTemplate.getProperties());
|
|
|
|
// GWTWorkflowTemplate gwtWorkflowReport = new GWTWorkflowTemplate(
|
|
|
|
// workflowTemplate.getId(),
|
|
|
|
// workflowTemplate.getName(),
|
|
|
|
// workflowTemplate.getDescription(),
|
|
|
|
// workflowTemplate.getOwner().getPortalLogin(),
|
|
|
|
// toDate(workflowTemplate.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(workflowTemplate.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(workflowTemplate.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// workflowTemplate.getLength()
|
|
|
|
// );
|
|
|
|
// gwtWorkflowReport.setWorkflowStatus(workflowTemplate.getWorkflowStatus());
|
|
|
|
// return gwtWorkflowReport;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTImageDocument buildGWTImageDocument(ImageDocument image, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(image.getProperties());
|
|
|
|
//
|
|
|
|
// Map<String, GWTDocumentMetadata> gwtmetadatas = getMetadatas(image.getMetadata(), image.getId());
|
|
|
|
//
|
|
|
|
// GWTImageDocument gwtImage = new GWTImageDocument(
|
|
|
|
// toDate(image.getCreationTime()),
|
|
|
|
// image.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// image.getName(),
|
|
|
|
// image.getOwner().getPortalLogin(),
|
|
|
|
// image.getDescription(),
|
|
|
|
// toDate(image.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(image.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// buildImageUrl(image.getId()),
|
|
|
|
// buildThumbnailUrl(image.getId()),
|
|
|
|
// image.getWidth(),
|
|
|
|
// image.getHeight(),
|
|
|
|
// image.getThumbnailWidth(),
|
|
|
|
// image.getThumbnailHeight(),
|
|
|
|
// image.getThumbnailLength(),
|
|
|
|
// image.getLength(),
|
|
|
|
// image.getMimeType(),
|
|
|
|
// image.getURI(),
|
|
|
|
// gwtmetadatas,
|
|
|
|
// new LinkedHashMap<String, String>(),
|
|
|
|
// image.getCollectionName(),
|
|
|
|
// image.getAlternatives().size(),
|
|
|
|
// image.getParts().size()
|
|
|
|
//
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtImage;
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTPDFDocument buildGWTPDFDocument(PDFDocument pdfDocument, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(pdfDocument.getProperties());
|
|
|
|
//
|
|
|
|
// Map<String, GWTDocumentMetadata> gwtmetadatas = getMetadatas(pdfDocument.getMetadata(), pdfDocument.getId());
|
|
|
|
//
|
|
|
|
// GWTPDFDocument gwtPDF = new GWTPDFDocument(
|
|
|
|
// toDate(pdfDocument.getCreationTime()),
|
|
|
|
// pdfDocument.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// pdfDocument.getName(),
|
|
|
|
// pdfDocument.getOwner().getPortalLogin(),
|
|
|
|
// pdfDocument.getDescription(),
|
|
|
|
// toDate(pdfDocument.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(pdfDocument.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// pdfDocument.getLength(),
|
|
|
|
// pdfDocument.getURI(),
|
|
|
|
// pdfDocument.getMimeType(),
|
|
|
|
// gwtmetadatas,
|
|
|
|
// new LinkedHashMap<String, String>(),
|
|
|
|
// pdfDocument.getCollectionName(),
|
|
|
|
// pdfDocument.getAlternatives().size(),
|
|
|
|
// pdfDocument.getParts().size(),
|
|
|
|
// pdfDocument.getAuthor(),
|
|
|
|
// pdfDocument.getNumberOfPages(),
|
|
|
|
// pdfDocument.getProducer(),
|
|
|
|
// pdfDocument.getTitle(),
|
|
|
|
// pdfDocument.getVersion(),
|
|
|
|
// "DocumentService?id="+pdfDocument.getId()
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtPDF;
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTDocument buildGWTDocument(Document document, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(document.getProperties());
|
|
|
|
//
|
|
|
|
// Map<String, GWTDocumentMetadata> gwtmetadatas = getMetadatas(document.getMetadata(), document.getId());
|
|
|
|
//
|
|
|
|
// GWTDocument gwtPDF = new GWTDocument(
|
|
|
|
// toDate(document.getCreationTime()),
|
|
|
|
// document.getId(),
|
|
|
|
// gwtProperties,
|
|
|
|
// document.getName(),
|
|
|
|
// document.getOwner().getPortalLogin(),
|
|
|
|
// document.getDescription(),
|
|
|
|
// toDate(document.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(document.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// document.getLength(),
|
|
|
|
// document.getURI(),
|
|
|
|
// document.getMimeType(),
|
|
|
|
// gwtmetadatas,
|
|
|
|
// new LinkedHashMap<String, String>(),
|
|
|
|
// document.getCollectionName(),
|
|
|
|
// document.getAlternatives().size(),
|
|
|
|
// document.getParts().size()
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtPDF;
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// protected GWTMetadata buildGWTMetadata(Metadata metadata, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
// {
|
|
|
|
// GWTProperties gwtProperties = buildGWTProperties(metadata.getProperties());
|
|
|
|
//
|
|
|
|
// GWTMetadata gwtMetadata = new GWTMetadata(
|
|
|
|
// metadata.getId(),
|
|
|
|
// metadata.getName(),
|
|
|
|
// metadata.getDescription(),
|
|
|
|
// metadata.getOwner().getPortalLogin(),
|
|
|
|
// toDate(metadata.getCreationTime()),
|
|
|
|
// gwtProperties,
|
|
|
|
// toDate(metadata.getLastModificationTime()),
|
|
|
|
// GWTWorkspaceItemAction.valueOf(metadata.getLastAction().toString()),
|
|
|
|
// parent,
|
|
|
|
// metadata.getLength(),
|
|
|
|
// metadata.getURI(),
|
|
|
|
// metadata.getSchema(),
|
|
|
|
// metadata.getLanguage(),
|
|
|
|
// metadata.getCollectionName(),
|
|
|
|
// "MetadataService?id="+metadata.getId()+"&type="+MetadataFormat.HTML,
|
|
|
|
// "MetadataService?id="+metadata.getId()+"&type="+MetadataFormat.RAW_XML_AS_HTML
|
|
|
|
// );
|
|
|
|
//
|
|
|
|
// return gwtMetadata;
|
|
|
|
//
|
|
|
|
// }
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
///////////////////////*********************USED
|
|
|
|
|
|
|
|
//ADD FRANCESCO
|
2015-05-20 18:39:49 +02:00
|
|
|
@SuppressWarnings("unchecked")
|
2013-02-06 15:40:17 +01:00
|
|
|
protected GWTWorkspaceItem buildGWTWorkspaceImage(WorkspaceItem item, boolean isInteralImage, boolean fullDetails) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
GWTWorkspaceItem gwtImage;
|
|
|
|
|
|
|
|
GWTProperties gwtProperties = buildGWTProperties(item.getProperties());
|
|
|
|
//
|
|
|
|
if(isInteralImage){
|
|
|
|
|
2015-05-20 18:39:49 +02:00
|
|
|
GCubeItem image = (GCubeItem) item; //Cast OLD Image Document
|
|
|
|
|
|
|
|
List<DocumentAlternativeLink> links = (List<DocumentAlternativeLink>) new XStream().fromXML(image.getItemProperties().get(NodeProperty.ALTERNATIVES.toString()));
|
|
|
|
List<DocumentPartLink> parts = (List<DocumentPartLink>) new XStream().fromXML(image.getItemProperties().get(NodeProperty.PARTS.toString()));
|
|
|
|
Map<String, DocumentMetadata> metadatas = (Map<String, DocumentMetadata>) new XStream().fromXML(image.getItemProperties().get(NodeProperty.METADATA.toString()));
|
|
|
|
Map<String, GWTDocumentMetadata> gwtmetadatas = getMetadatas(metadatas, image.getId());
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
gwtImage = (GWTImageDocument) new GWTImageDocument(
|
|
|
|
toDate(image.getCreationTime()),
|
|
|
|
image.getId(),
|
|
|
|
gwtProperties,
|
|
|
|
image.getName(),
|
|
|
|
image.getOwner().getPortalLogin(),
|
|
|
|
image.getDescription(),
|
|
|
|
toDate(image.getLastModificationTime()),
|
|
|
|
GWTWorkspaceItemAction.valueOf(image.getLastAction().toString()),
|
|
|
|
null,
|
|
|
|
buildImageUrl(image.getId()),
|
|
|
|
buildThumbnailUrl(image.getId()),
|
2015-05-20 18:39:49 +02:00
|
|
|
Integer.parseInt(image.getItemProperties().get(NodeProperty.IMAGE_WIDTH.toString())),
|
|
|
|
Integer.parseInt(image.getItemProperties().get(NodeProperty.IMAGE_HEIGHT.toString())),
|
|
|
|
Integer.parseInt(image.getItemProperties().get(NodeProperty.THUMBNAIL_WIDTH.toString())),
|
|
|
|
Integer.parseInt(image.getItemProperties().get(NodeProperty.THUMBNAIL_HEIGHT.toString())),
|
|
|
|
-1,
|
2013-02-06 15:40:17 +01:00
|
|
|
image.getLength(),
|
|
|
|
image.getMimeType(),
|
2015-05-20 18:39:49 +02:00
|
|
|
image.getItemProperties().get(NodeProperty.OID.toString()),
|
2013-02-06 15:40:17 +01:00
|
|
|
gwtmetadatas,
|
|
|
|
new LinkedHashMap<String, String>(),
|
2015-05-20 18:39:49 +02:00
|
|
|
image.getItemProperties().get(NodeProperty.COLLECTION_NAME.toString()),
|
|
|
|
links.size(),
|
|
|
|
parts.size());
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
else{
|
|
|
|
|
|
|
|
ExternalImage image = (ExternalImage) item; //Cast External Document
|
|
|
|
|
|
|
|
if(fullDetails){
|
|
|
|
|
|
|
|
gwtImage = new GWTExternalImage(
|
|
|
|
toDate(image.getCreationTime()),
|
|
|
|
image.getId(),
|
|
|
|
gwtProperties,
|
|
|
|
image.getName(),
|
|
|
|
image.getOwner().getPortalLogin(),
|
|
|
|
image.getDescription(),
|
|
|
|
toDate(image.getLastModificationTime()),
|
|
|
|
GWTWorkspaceItemAction.valueOf(image.getLastAction().toString()),
|
|
|
|
null, //parent
|
|
|
|
buildImageUrl(image.getId()),
|
|
|
|
buildThumbnailUrl(image.getId()),
|
|
|
|
image.getWidth(),
|
|
|
|
image.getHeight(),
|
|
|
|
image.getLength(),
|
|
|
|
image.getThumbnailWidth(),
|
|
|
|
image.getThumbnailHeight(),
|
2015-05-20 18:39:49 +02:00
|
|
|
-1,
|
2013-02-06 15:40:17 +01:00
|
|
|
image.getMimeType());
|
2015-05-20 18:39:49 +02:00
|
|
|
}else{
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
gwtImage = new GWTExternalImage(
|
|
|
|
buildImageUrl(image.getId()),
|
|
|
|
buildThumbnailUrl(image.getId()),
|
|
|
|
image.getWidth(),
|
|
|
|
image.getHeight(),
|
|
|
|
image.getLength(),
|
|
|
|
image.getThumbnailWidth(),
|
|
|
|
image.getThumbnailHeight(),
|
2015-05-20 18:39:49 +02:00
|
|
|
-1,
|
2013-02-06 15:40:17 +01:00
|
|
|
image.getMimeType());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return gwtImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected GWTExternalUrl buildGWTExternalUrl(ExternalUrl url, GWTWorkspaceFolder parent) throws InternalErrorException
|
|
|
|
{
|
|
|
|
GWTProperties gwtProperties = buildGWTProperties(url.getProperties());
|
|
|
|
GWTExternalUrl gwtUrl = new GWTExternalUrl(
|
|
|
|
toDate(url.getCreationTime()),
|
|
|
|
url.getId(),
|
|
|
|
gwtProperties,
|
|
|
|
url.getName(),
|
|
|
|
url.getOwner().getPortalLogin(),
|
|
|
|
url.getDescription(),
|
|
|
|
toDate(url.getLastModificationTime()),
|
|
|
|
GWTWorkspaceItemAction.valueOf(url.getLastAction().toString()),
|
|
|
|
parent,
|
|
|
|
url.getLength(),
|
|
|
|
url.getUrl());
|
|
|
|
|
|
|
|
return gwtUrl;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-20 18:39:49 +02:00
|
|
|
@SuppressWarnings("unchecked")
|
2013-02-06 15:40:17 +01:00
|
|
|
protected GWTWorkspaceItem buildGWTWorspaceUrl(WorkspaceItem item, boolean isInternalUrl, boolean fullDetails) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
GWTWorkspaceItem gwtUrl = null;
|
|
|
|
|
|
|
|
GWTProperties gwtProperties = buildGWTProperties(item.getProperties());
|
|
|
|
|
|
|
|
// GWTUrlDocument gwtUrlDocument = null;
|
|
|
|
|
|
|
|
if(isInternalUrl){
|
|
|
|
|
2015-05-20 18:39:49 +02:00
|
|
|
GCubeItem document = (GCubeItem) item; //Cast OLD UrlDocument
|
|
|
|
// UrlDocument document = (UrlDocument) item; //Cast
|
|
|
|
List<DocumentAlternativeLink> links = (List<DocumentAlternativeLink>) new XStream().fromXML(document.getItemProperties().get(NodeProperty.ALTERNATIVES.toString()));
|
|
|
|
List<DocumentPartLink> parts = (List<DocumentPartLink>) new XStream().fromXML(document.getItemProperties().get(NodeProperty.PARTS.toString()));
|
|
|
|
Map<String, DocumentMetadata> metadatas = (Map<String, DocumentMetadata>) new XStream().fromXML(document.getItemProperties().get(NodeProperty.METADATA.toString()));
|
|
|
|
Map<String, GWTDocumentMetadata> gwtmetadatas = getMetadatas(metadatas, document.getId());
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
gwtUrl = new GWTUrlDocument(
|
|
|
|
toDate(document.getCreationTime()),
|
|
|
|
document.getId(),
|
|
|
|
gwtProperties,
|
|
|
|
document.getName(),
|
|
|
|
document.getOwner().getPortalLogin(),
|
|
|
|
document.getDescription(),
|
|
|
|
toDate(document.getLastModificationTime()),
|
|
|
|
GWTWorkspaceItemAction.valueOf(document.getLastAction().toString()),
|
|
|
|
null,
|
|
|
|
document.getLength(),
|
2015-05-20 18:39:49 +02:00
|
|
|
document.getItemProperties().get(NodeProperty.OID.toString()),
|
2013-02-06 15:40:17 +01:00
|
|
|
document.getMimeType(),
|
|
|
|
gwtmetadatas,
|
|
|
|
new LinkedHashMap<String, String>(),
|
2015-05-20 18:39:49 +02:00
|
|
|
document.getItemProperties().get(NodeProperty.COLLECTION_NAME.toString()),
|
|
|
|
links.size(),
|
|
|
|
parts.size(),
|
|
|
|
document.getItemProperties().get(NodeProperty.URL.toString()));
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
else{
|
|
|
|
|
|
|
|
ExternalUrl document = (ExternalUrl) item; //Cast
|
|
|
|
|
|
|
|
if(fullDetails){
|
|
|
|
|
|
|
|
gwtUrl = new GWTExternalUrl(
|
|
|
|
toDate(document.getCreationTime()),
|
|
|
|
document.getId(),
|
|
|
|
gwtProperties,
|
|
|
|
document.getName(),
|
|
|
|
document.getOwner().getPortalLogin(),
|
|
|
|
document.getDescription(),
|
|
|
|
toDate(document.getLastModificationTime()),
|
|
|
|
GWTWorkspaceItemAction.valueOf(document.getLastAction().toString()),
|
|
|
|
null,
|
|
|
|
document.getLength(),
|
|
|
|
document.getUrl());
|
|
|
|
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
|
|
|
|
gwtUrl = new GWTExternalUrl(document.getUrl());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return gwtUrl;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
protected Map<String, GWTDocumentMetadata> getMetadatas(Map<String, DocumentMetadata> metadatas, String documentId)
|
|
|
|
{
|
|
|
|
Map<String, GWTDocumentMetadata> gwtmetadatas = new LinkedHashMap<String, GWTDocumentMetadata>();
|
|
|
|
|
|
|
|
for (Entry<String, DocumentMetadata> metadata : metadatas.entrySet()) gwtmetadatas.put(metadata.getKey(), getMetadata(metadata.getValue(), documentId));
|
|
|
|
|
|
|
|
return gwtmetadatas;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected GWTDocumentMetadata getMetadata(DocumentMetadata metadata, String documentId)
|
|
|
|
{
|
|
|
|
return new GWTDocumentMetadata(metadata.getSchemaName(),
|
|
|
|
"MetadataService?id="+documentId+"&schema="+metadata.getSchemaName()+"&type="+MetadataFormat.HTML,
|
|
|
|
"MetadataService?id="+documentId+"&schema="+metadata.getSchemaName()+"&type="+MetadataFormat.RAW_XML_AS_HTML,
|
|
|
|
"MetadataService?id="+documentId+"&schema="+metadata.getSchemaName()+"&type="+MetadataFormat.FORMATTED_XML);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//*****************************************************NEW
|
|
|
|
|
|
|
|
|
|
|
|
public FolderModel buildWorkspaceFileModelRoot(WorkspaceFolder workspaceRoot) throws InternalErrorException {
|
|
|
|
|
|
|
|
logger.trace("workspace id: "+ workspaceRoot.getId());
|
|
|
|
logger.trace("workspace name: "+ workspaceRoot.getName());
|
|
|
|
logger.trace("workspace path "+ workspaceRoot.getPath());
|
|
|
|
|
2014-02-13 15:19:42 +01:00
|
|
|
FolderModel root = new FolderModel(workspaceRoot.getId(),workspaceRoot.getName(),null, true, workspaceRoot.isShared(), false);
|
2013-02-06 15:40:17 +01:00
|
|
|
root.setIsRoot(true);
|
|
|
|
|
|
|
|
return root;
|
|
|
|
}
|
|
|
|
|
2013-02-12 17:17:15 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
protected List<FileModel> buildGXTListFileModelItem(WorkspaceItem workspaceFolder, FileModel parentFolderModel) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
List<FileModel> listFileModel = new ArrayList<FileModel>();
|
|
|
|
|
|
|
|
List<WorkspaceItem> listItems = (List<WorkspaceItem>) workspaceFolder.getChildren();
|
|
|
|
|
2013-07-08 17:42:08 +02:00
|
|
|
if(listItems!=null)
|
|
|
|
logger.trace("HL return "+listItems.size()+ "items, converting...");
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
//TEST TIME
|
|
|
|
// Long startTime = System.currentTimeMillis();
|
|
|
|
// Long endTime = System.currentTimeMillis() - startTime;
|
|
|
|
// String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
|
|
// logger.trace("tree getChildren() returning "+listItems.size()+" elements in " + time);
|
|
|
|
// startTime = System.currentTimeMillis();
|
|
|
|
|
|
|
|
for (WorkspaceItem item : listItems){
|
|
|
|
listFileModel.add(buildGXTFileModelItem(item,parentFolderModel));
|
|
|
|
}
|
|
|
|
|
|
|
|
//TEST TIME
|
|
|
|
// endTime = System.currentTimeMillis() - startTime;
|
|
|
|
// time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
|
|
|
// logger.trace("tree gxt objects getChildren() returning "+listItems.size()+" elements in " + time);
|
|
|
|
|
|
|
|
return listFileModel;
|
|
|
|
|
|
|
|
// return buildGXTListFileModelItem((WorkspaceItem) workspaceFolder.getChildren(), parentFolderModel);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
protected List<FileModel> buildGXTListFileModelItemForAttachs(List<WorkspaceItem> listWorspaceItems) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
List<FileModel> listFileModel = new ArrayList<FileModel>();
|
|
|
|
|
|
|
|
for (WorkspaceItem item : listWorspaceItems){
|
|
|
|
|
|
|
|
FileModel fileModel = null;
|
|
|
|
|
|
|
|
switch (item.getType()) {
|
|
|
|
|
2014-02-13 15:19:42 +01:00
|
|
|
case FOLDER: fileModel = new FolderModel(item.getId(), item.getName(), true, false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.FOLDER.toString());
|
|
|
|
break;
|
|
|
|
|
|
|
|
case FOLDER_ITEM:
|
|
|
|
fileModel = new FileModel(item.getId(), item.getName(), false);
|
|
|
|
FolderItem folderItem = (FolderItem) item;
|
|
|
|
fileModel = setFolderItemType(fileModel, folderItem);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SHARED_FOLDER:
|
|
|
|
|
2014-02-13 16:12:37 +01:00
|
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) item;
|
|
|
|
String name = shared.isVreFolder()?shared.getDisplayName():item.getName();
|
|
|
|
|
|
|
|
fileModel = new FolderModel(item.getId(), name, true, shared.isVreFolder());
|
2013-02-06 15:40:17 +01:00
|
|
|
fileModel.setShared(true);
|
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.SHARED_FOLDER.toString());
|
2014-02-13 15:19:42 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
logger.error("gxt conversion return null for item "+item.getName());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
listFileModel.add(fileModel);
|
|
|
|
}
|
|
|
|
return listFileModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param listPortalLogin
|
|
|
|
* @return
|
|
|
|
*/
|
2013-05-27 18:25:10 +02:00
|
|
|
public List<InfoContactModel> buildGxtInfoContactsFromPortalLogins(List<String> listPortalLogin){
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
List<InfoContactModel> listContact = new ArrayList<InfoContactModel>();
|
2014-07-11 15:56:35 +02:00
|
|
|
|
|
|
|
if(listPortalLogin!=null && listPortalLogin.size()>0){
|
|
|
|
for (String portalLogin : listPortalLogin)
|
|
|
|
listContact.add(buildGxtInfoContactFromPortalLogin(portalLogin));
|
|
|
|
}
|
|
|
|
|
2013-03-11 19:06:56 +01:00
|
|
|
return listContact;
|
|
|
|
}
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param portalLogin
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
protected InfoContactModel buildGxtInfoContactFromPortalLogin(String portalLogin){
|
|
|
|
|
|
|
|
if(portalLogin==null){
|
|
|
|
logger.warn("portal login is null, return empty");
|
|
|
|
portalLogin = "";
|
|
|
|
}
|
|
|
|
|
2014-03-10 17:33:33 +01:00
|
|
|
return new InfoContactModel(portalLogin, portalLogin, UserUtil.getUserFullName(portalLogin), false);
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
}
|
2015-03-06 16:12:21 +01:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-03-11 19:06:56 +01:00
|
|
|
/**
|
|
|
|
* Used in test mode
|
|
|
|
* @param listPortalLogin
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
protected List<InfoContactModel> buildGxtInfoContactFromPortalLoginTestMode(List<String> listPortalLogin){
|
|
|
|
|
|
|
|
List<InfoContactModel> listContact = new ArrayList<InfoContactModel>();
|
|
|
|
|
|
|
|
for (String portalLogin : listPortalLogin)
|
|
|
|
listContact.add(getHashTestUsers().get(portalLogin));
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return listContact;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
protected FileModel buildGXTFileModelItem(WorkspaceItem item, FileModel parentFolderModel) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
FileModel fileModel = null;
|
|
|
|
|
|
|
|
switch (item.getType()) {
|
|
|
|
|
|
|
|
case FOLDER:
|
|
|
|
|
2014-02-13 15:19:42 +01:00
|
|
|
fileModel = new FolderModel(item.getId(), item.getName(), (FolderModel) parentFolderModel, true, false, false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.FOLDER.toString());
|
2013-02-12 16:02:00 +01:00
|
|
|
fileModel.setShareable(true);
|
2013-02-25 19:03:53 +01:00
|
|
|
fileModel.setDescription(item.getDescription());
|
2014-02-12 19:46:39 +01:00
|
|
|
|
2014-02-13 15:19:42 +01:00
|
|
|
// WorkspaceFolder folder = (WorkspaceFolder) item;
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FOLDER_ITEM:
|
2014-02-13 15:19:42 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
// fileModel = new FileModel(item.getId(), item.getName(), item.getPath(), (FolderModel) parentFolderModel, false);
|
|
|
|
fileModel = new FileModel(item.getId(), item.getName(), (FolderModel) parentFolderModel, false, false);
|
|
|
|
FolderItem folderItem = (FolderItem) item;
|
|
|
|
fileModel = setFolderItemType(fileModel, folderItem);
|
2013-02-12 17:17:15 +01:00
|
|
|
fileModel.setShareable(true);
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SHARED_FOLDER:
|
2014-02-13 15:19:42 +01:00
|
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) item;
|
|
|
|
String name = shared.isVreFolder()?shared.getDisplayName():item.getName();
|
2014-02-13 16:12:37 +01:00
|
|
|
fileModel = new FolderModel(item.getId(), name, (FolderModel) parentFolderModel, true, true, shared.isVreFolder());
|
2013-02-06 15:40:17 +01:00
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.SHARED_FOLDER.toString());
|
2013-02-12 16:02:00 +01:00
|
|
|
fileModel.setShareable(true);
|
2013-02-25 19:03:53 +01:00
|
|
|
fileModel.setDescription(item.getDescription());
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
// WorkspaceSharedFolder sharedFolder = (WorkspaceSharedFolder) item;
|
|
|
|
// fileModel.setListShareUser(buildGxtInfoContactFromPortalLogin(sharedFolder.getUsers()));
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
logger.error("gxt conversion return null for item "+item.getName());
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
//ACCOUNTING
|
2015-02-24 15:31:22 +01:00
|
|
|
//REMOVED IS MARK AS READ FROM HL
|
|
|
|
// fileModel.setMarkAsRead(item.isMarkedAsRead());
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-06-06 18:04:06 +02:00
|
|
|
if(parentFolderModel!=null && parentFolderModel.isShared()){
|
2013-02-06 15:40:17 +01:00
|
|
|
fileModel.setShared(true);
|
2015-01-28 12:42:48 +01:00
|
|
|
fileModel.setShareable(false); //UPDATED TO CHANGE PERMISSIONS TO SHARED SUBFOLDERS
|
|
|
|
// fileModel.setShareable(true);
|
2013-02-12 16:02:00 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
// fileModel.setOwner(new InfoContactModel(item.getOwner().getId(), item.getOwner().getPortalLogin(), "name"));
|
|
|
|
//// fileModel.setShared(item.isShared());
|
|
|
|
|
|
|
|
return fileModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-10 15:44:12 +01:00
|
|
|
public List<FileGridModel> buildGXTListFileGridModelItemForSearch(List<SearchItem> listSearchItems) throws InternalErrorException
|
2013-02-06 15:40:17 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
List<FileGridModel> listFileGridModel = new ArrayList<FileGridModel>();
|
|
|
|
|
2013-11-15 12:12:17 +01:00
|
|
|
FileModel parentFileModel = null;
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
for (SearchItem item : listSearchItems)
|
|
|
|
listFileGridModel.add(buildGXTFileGridModelItemForSearch(item,parentFileModel));
|
|
|
|
|
|
|
|
|
|
|
|
return listFileGridModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
private FileGridModel buildGXTFileGridModelItemForSearch(SearchItem item, FileModel parentFileModel) throws InternalErrorException{
|
|
|
|
|
|
|
|
FileGridModel fileGridModel = null;
|
2014-01-13 11:54:11 +01:00
|
|
|
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
switch (item.getType()) {
|
|
|
|
|
|
|
|
case FOLDER:
|
2013-11-15 12:12:17 +01:00
|
|
|
// fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), item.getName(), toDate(item.getCreationDate()), parentFileModel, -1, true, false);
|
2014-02-13 15:19:42 +01:00
|
|
|
fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), item.getName(), toDate(item.getLastModified()), parentFileModel, -1, true, false,false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel.setType(GXTFolderItemTypeEnum.FOLDER.toString());
|
|
|
|
fileGridModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
2013-02-12 16:02:00 +01:00
|
|
|
fileGridModel.setShareable(true);
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FOLDER_ITEM:
|
2014-02-25 16:50:32 +01:00
|
|
|
SearchFolderItem folderItem = (SearchFolderItem) item;
|
2013-11-15 12:12:17 +01:00
|
|
|
fileGridModel = new FileGridModel(item.getId(), item.getName(), toDate(item.getLastModified()), parentFileModel, folderItem.getSize(), false, false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel = (FileGridModel) setFolderItemTypeForSearch(fileGridModel, folderItem);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SHARED_FOLDER:
|
|
|
|
|
2014-02-24 19:11:41 +01:00
|
|
|
//ATTENTION: SEARCH ITEM IS NOT CASTABLE AT WorkspaceSharedFolder
|
|
|
|
fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), item.getName(), toDate(item.getLastModified()), parentFileModel, -1, true, true, item.isVreFolder());
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel.setType(GXTFolderItemTypeEnum.SHARED_FOLDER.toString());
|
|
|
|
fileGridModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
2013-02-12 16:02:00 +01:00
|
|
|
fileGridModel.setShareable(true);
|
2014-02-25 16:50:32 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
logger.error("gxt conversion return null for item "+item.getName());
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-02-24 19:11:41 +01:00
|
|
|
//TODO ISSHARED IN SEARCH ITEM IN HL TO RETRIEVE SHARE ON WORKSPACEITEM
|
2015-03-03 17:13:29 +01:00
|
|
|
|
2014-02-24 19:11:41 +01:00
|
|
|
|
2013-11-15 12:12:17 +01:00
|
|
|
//OWNER
|
2014-02-25 16:50:32 +01:00
|
|
|
if(item.isShared()){ //IS READ FROM HL ONLY IF THE ITEM IS SHARED
|
2014-11-10 15:44:12 +01:00
|
|
|
fileGridModel.setShared(true); //TEMPORARY SOLUTION: ADDED TO FIX WRONG TYPE SearchFolderItem
|
2013-11-15 12:12:17 +01:00
|
|
|
String portalLogin = item.getOwner();
|
|
|
|
if(portalLogin!=null){
|
|
|
|
String fullName = portalLogin;
|
2015-01-28 15:02:18 +01:00
|
|
|
fullName = UserUtil.getUserFullName(portalLogin);
|
2013-11-15 12:12:17 +01:00
|
|
|
fileGridModel.setOwnerFullName(fullName);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
if(userLogged!=null)
|
|
|
|
fileGridModel.setOwnerFullName(userLogged.getName());
|
2014-02-25 16:50:32 +01:00
|
|
|
}
|
2014-02-24 19:11:41 +01:00
|
|
|
|
2013-11-15 12:12:17 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return fileGridModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<FileGridModel> buildGXTListFileGridModelItem(List<WorkspaceItem> listWorkspaceItems, FileModel parentFileModel) throws InternalErrorException
|
|
|
|
{
|
|
|
|
|
|
|
|
Long startTime = System.currentTimeMillis();
|
|
|
|
|
|
|
|
List<FileGridModel> listFileGridModel = new ArrayList<FileGridModel>();
|
|
|
|
|
|
|
|
for (WorkspaceItem item : listWorkspaceItems)
|
|
|
|
listFileGridModel.add(buildGXTFileGridModelItem(item,parentFileModel));
|
|
|
|
|
|
|
|
Long endTime = System.currentTimeMillis() - startTime;
|
|
|
|
String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
|
2013-09-04 11:26:10 +02:00
|
|
|
logger.trace("##GRID FILLING: gxt grid objects getChildren() returning "+listWorkspaceItems.size()+" elements in " + time);
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
|
|
|
|
return listFileGridModel;
|
|
|
|
}
|
|
|
|
|
2013-12-16 15:53:39 +01:00
|
|
|
public FileGridModel buildGXTFileGridModelItem(WorkspaceItem item, FileModel parentFileModel) throws InternalErrorException{
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
|
|
|
|
FileGridModel fileGridModel = null;
|
|
|
|
|
|
|
|
switch (item.getType()) {
|
|
|
|
|
|
|
|
case FOLDER:
|
2013-11-15 12:12:17 +01:00
|
|
|
// fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), item.getName(), toDate(item.getCreationTime()), parentFileModel, -1, true, false);
|
2014-02-13 15:19:42 +01:00
|
|
|
fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), item.getName(), toDate(item.getLastModificationTime()), parentFileModel, -1, true, false,false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel.setType(GXTFolderItemTypeEnum.FOLDER.toString());
|
|
|
|
fileGridModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
2013-02-12 16:02:00 +01:00
|
|
|
fileGridModel.setShareable(true);
|
2013-02-25 19:03:53 +01:00
|
|
|
fileGridModel.setDescription(item.getDescription());
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FOLDER_ITEM:
|
|
|
|
|
|
|
|
FolderItem folderItem = (FolderItem) item;
|
2013-11-15 12:12:17 +01:00
|
|
|
// fileGridModel = new FileGridModel(item.getId(), item.getName(), toDate(item.getCreationTime()), parentFileModel, folderItem.getLength(), false, false);
|
|
|
|
fileGridModel = new FileGridModel(item.getId(), item.getName(), toDate(item.getLastModificationTime()), parentFileModel, folderItem.getLength(), false, false);
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel = (FileGridModel) setFolderItemType(fileGridModel, folderItem);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SHARED_FOLDER:
|
2014-02-13 15:19:42 +01:00
|
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) item;
|
|
|
|
String name = shared.isVreFolder()?shared.getDisplayName():item.getName();
|
|
|
|
fileGridModel = (FolderGridModel) new FolderGridModel(item.getId(), name, toDate(item.getLastModificationTime()), parentFileModel, -1, true, true, shared.isVreFolder());
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel.setType(GXTFolderItemTypeEnum.SHARED_FOLDER.toString());
|
|
|
|
fileGridModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
2013-02-12 16:02:00 +01:00
|
|
|
fileGridModel.setShareable(true);
|
2013-02-25 19:03:53 +01:00
|
|
|
fileGridModel.setDescription(item.getDescription());
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
logger.error("gxt conversion return null for item "+item.getName());
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-06-06 18:04:06 +02:00
|
|
|
if(parentFileModel!=null && parentFileModel.isShared()){
|
2013-02-06 15:40:17 +01:00
|
|
|
fileGridModel.setShared(true);
|
2015-01-28 12:42:48 +01:00
|
|
|
fileGridModel.setShareable(false); //UPDATED TO CHANGE PERMISSIONS TO SHARED SUBFOLDERS
|
|
|
|
// fileGridModel.setShareable(true);
|
2013-02-12 16:02:00 +01:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2013-09-03 15:49:22 +02:00
|
|
|
//OWNER
|
2013-09-04 11:26:10 +02:00
|
|
|
if(fileGridModel.isShared()){ //IS READ FROM HL ONLY IF THE ITEM IS SHARED
|
|
|
|
User owner = item.getOwner();
|
2013-09-04 11:27:11 +02:00
|
|
|
if(owner!=null){
|
2013-09-04 11:26:10 +02:00
|
|
|
// System.out.println("++++reading owner");
|
|
|
|
String portalLogin = owner.getPortalLogin();
|
2013-09-03 15:49:22 +02:00
|
|
|
String fullName = portalLogin;
|
2015-01-28 15:02:18 +01:00
|
|
|
fullName = UserUtil.getUserFullName(portalLogin);
|
2013-09-04 11:26:10 +02:00
|
|
|
fileGridModel.setOwnerFullName(fullName);
|
2013-09-03 15:49:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
if(userLogged!=null)
|
2013-09-04 11:26:10 +02:00
|
|
|
// fileGridModel.setOwner(new InfoContactModel(userLogged.getId(), userLogged.getLogin(), userLogged.getName()));
|
|
|
|
fileGridModel.setOwnerFullName(userLogged.getName());
|
2013-09-03 15:49:22 +02:00
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
//// fileGridModel.setShared(item.isShared());
|
|
|
|
|
|
|
|
return fileGridModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
protected FileModel setFolderItemTypeForSearch(FileModel fileModel, SearchFolderItem searchFolderItem){
|
|
|
|
|
|
|
|
if(searchFolderItem.getFolderItemType()==null){
|
|
|
|
logger.trace("Search folder item type is null for "+searchFolderItem.getId() + " name: "+searchFolderItem.getName());
|
|
|
|
//FOR DEBUG
|
2013-10-03 14:45:25 +02:00
|
|
|
// System.out.println("Search folder item type is null for "+searchFolderItem.getId() + " name: "+searchFolderItem.getName());
|
2013-02-06 15:40:17 +01:00
|
|
|
return fileModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(searchFolderItem.getFolderItemType())
|
|
|
|
{
|
|
|
|
case EXTERNAL_IMAGE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_IMAGE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_IMAGES);
|
|
|
|
fileModel.setType(searchFolderItem.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_FILE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_FILE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
fileModel.setType(searchFolderItem.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_PDF_FILE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_PDF_FILE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
fileModel.setType(searchFolderItem.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_URL:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_URL);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_LINKS);
|
|
|
|
break;
|
|
|
|
case REPORT_TEMPLATE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.REPORT_TEMPLATE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_REPORTS);
|
|
|
|
break;
|
|
|
|
case REPORT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.REPORT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_REPORTS);
|
|
|
|
break;
|
|
|
|
case QUERY:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.QUERY);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case TIME_SERIES:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.TIME_SERIES);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_TIMESERIES);
|
|
|
|
break;
|
|
|
|
// case AQUAMAPS_ITEM:
|
|
|
|
// fileModel.setFolderItemType(GXTFolderItemTypeEnum.AQUAMAPS_ITEM);
|
|
|
|
// fileModel.setShortcutCategory(GXTCategoryItemInterface.BIODIVERSITY);
|
|
|
|
// break;
|
|
|
|
case PDF_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.PDF_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case IMAGE_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.IMAGE_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_IMAGES);
|
|
|
|
fileModel.setType(searchFolderItem.getMimeType());
|
|
|
|
break;
|
|
|
|
case DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
fileModel.setType(searchFolderItem.getMimeType());
|
|
|
|
break;
|
|
|
|
case URL_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.URL_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case METADATA:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.METADATA);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case WORKFLOW_REPORT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.WORKFLOW_REPORT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case WORKFLOW_TEMPLATE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.WORKFLOW_TEMPLATE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
// logger.trace("**************************************DOCUMENTS******* filemodel "+ fileModel.getName());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_RESOURCE_LINK:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_RESOURCE_LINK);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_LINKS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.UNKNOWN_TYPE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_UNKNOWN);
|
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.UNKNOWN_TYPE.toString());
|
|
|
|
// logger.trace("**************************************UNKNOWN******* filemodel "+ fileModel.getName());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fileModel;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected FileModel setFolderItemType(FileModel fileModel, FolderItem worspaceFolderItem){
|
|
|
|
|
|
|
|
switch(worspaceFolderItem.getFolderItemType())
|
|
|
|
{
|
|
|
|
case EXTERNAL_IMAGE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_IMAGE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_IMAGES);
|
|
|
|
ExternalImage extImage = (ExternalImage) worspaceFolderItem;
|
|
|
|
fileModel.setType(extImage.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_FILE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_FILE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
ExternalFile extFile = (ExternalFile) worspaceFolderItem;
|
|
|
|
fileModel.setType(extFile.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_PDF_FILE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_PDF_FILE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
ExternalPDFFile pdfExt = (ExternalPDFFile) worspaceFolderItem;
|
|
|
|
fileModel.setType(pdfExt.getMimeType());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_URL:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_URL);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_LINKS);
|
|
|
|
break;
|
|
|
|
case REPORT_TEMPLATE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.REPORT_TEMPLATE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_REPORTS);
|
|
|
|
break;
|
|
|
|
case REPORT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.REPORT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_REPORTS);
|
|
|
|
break;
|
|
|
|
case QUERY:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.QUERY);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case TIME_SERIES:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.TIME_SERIES);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_TIMESERIES);
|
|
|
|
break;
|
|
|
|
// case AQUAMAPS_ITEM:
|
|
|
|
// fileModel.setFolderItemType(GXTFolderItemTypeEnum.AQUAMAPS_ITEM);
|
|
|
|
// fileModel.setShortcutCategory(GXTCategoryItemInterface.BIODIVERSITY);
|
|
|
|
// break;
|
|
|
|
case PDF_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.PDF_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case IMAGE_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.IMAGE_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_IMAGES);
|
2015-05-20 18:39:49 +02:00
|
|
|
// ImageDocument imgDoc = (ImageDocument) worspaceFolderItem;
|
|
|
|
GCubeItem imgDoc = (GCubeItem) worspaceFolderItem; //Cast GCubeItem
|
|
|
|
try {
|
|
|
|
fileModel.setType(imgDoc.getMimeType());
|
|
|
|
} catch (InternalErrorException e) {
|
|
|
|
// TODO Auto-generated catch block
|
|
|
|
logger.error("IMAGE_DOCUMENT InternalErrorException when getting MimeType on "+fileModel.getIdentifier());
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
case DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
2015-05-20 18:39:49 +02:00
|
|
|
// Document doc = (Document) worspaceFolderItem;
|
|
|
|
GCubeItem doc = (GCubeItem) worspaceFolderItem; //Cast GCubeItem
|
|
|
|
try {
|
|
|
|
fileModel.setType(doc.getMimeType());
|
|
|
|
} catch (InternalErrorException e) {
|
|
|
|
// TODO Auto-generated catch block
|
|
|
|
logger.error("DOCUMENT InternalErrorException when getting MimeType on "+fileModel.getIdentifier());
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
break;
|
|
|
|
case URL_DOCUMENT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.URL_DOCUMENT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case METADATA:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.METADATA);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case WORKFLOW_REPORT:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.WORKFLOW_REPORT);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
break;
|
|
|
|
case WORKFLOW_TEMPLATE:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.WORKFLOW_TEMPLATE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_DOCUMENTS);
|
|
|
|
// logger.trace("**************************************DOCUMENTS******* filemodel "+ fileModel.getName());
|
|
|
|
break;
|
|
|
|
case EXTERNAL_RESOURCE_LINK:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.EXTERNAL_RESOURCE_LINK);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_LINKS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fileModel.setFolderItemType(GXTFolderItemTypeEnum.UNKNOWN_TYPE);
|
|
|
|
fileModel.setShortcutCategory(GXTCategoryItemInterface.SMF_UNKNOWN);
|
|
|
|
fileModel.setType(GXTFolderItemTypeEnum.UNKNOWN_TYPE.toString());
|
|
|
|
// logger.trace("**************************************UNKNOWN******* filemodel "+ fileModel.getName());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fileModel;
|
|
|
|
}
|
2013-07-08 17:42:08 +02:00
|
|
|
|
|
|
|
public String getPubliLinkForFolderItem(FolderItem worspaceFolderItem) throws InternalErrorException{
|
|
|
|
|
|
|
|
if(worspaceFolderItem==null)
|
|
|
|
return "";
|
|
|
|
|
|
|
|
try{
|
|
|
|
|
|
|
|
switch(worspaceFolderItem.getFolderItemType())
|
|
|
|
{
|
|
|
|
case EXTERNAL_IMAGE:
|
|
|
|
return ((ExternalImage) worspaceFolderItem).getPublicLink();
|
|
|
|
case EXTERNAL_FILE:
|
|
|
|
return ((ExternalFile) worspaceFolderItem).getPublicLink();
|
|
|
|
case EXTERNAL_PDF_FILE:
|
|
|
|
return ((ExternalPDFFile) worspaceFolderItem).getPublicLink();
|
|
|
|
case EXTERNAL_URL:
|
|
|
|
break;
|
|
|
|
case REPORT_TEMPLATE:
|
|
|
|
break;
|
|
|
|
case REPORT:
|
|
|
|
break;
|
|
|
|
case QUERY:
|
|
|
|
break;
|
|
|
|
case TIME_SERIES:
|
|
|
|
break;
|
|
|
|
// case AQUAMAPS_ITEM:
|
|
|
|
// break;
|
|
|
|
case PDF_DOCUMENT:
|
|
|
|
break;
|
|
|
|
case IMAGE_DOCUMENT:
|
2015-05-20 18:39:49 +02:00
|
|
|
GCubeItem imgDoc = (GCubeItem) worspaceFolderItem; //Cast GCubeItem
|
|
|
|
return imgDoc.getPublicLink(false);
|
|
|
|
// return ((ImageDocument) worspaceFolderItem).getPublicLink();
|
2013-07-08 17:42:08 +02:00
|
|
|
case DOCUMENT:
|
|
|
|
break;
|
|
|
|
case URL_DOCUMENT:
|
|
|
|
break;
|
|
|
|
case METADATA:
|
|
|
|
break;
|
|
|
|
case WORKFLOW_REPORT:
|
|
|
|
break;
|
|
|
|
case WORKFLOW_TEMPLATE:
|
|
|
|
break;
|
|
|
|
case EXTERNAL_RESOURCE_LINK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
}catch (Exception e) {
|
|
|
|
logger.error("an error occurred when get public link for item: "+worspaceFolderItem.getName());
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
return "";
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2013-02-13 18:39:33 +01:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param wsFolder
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
2013-02-06 15:40:17 +01:00
|
|
|
public FolderModel buildGXTFolderModelItem(WorkspaceFolder wsFolder, FileModel parent) throws InternalErrorException {
|
|
|
|
|
2014-02-13 18:40:59 +01:00
|
|
|
String name = "";
|
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
//MANAGEMENT SHARED FOLDER NAME
|
2014-02-19 15:32:04 +01:00
|
|
|
if(wsFolder.isShared() && wsFolder.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
|
2014-02-13 18:40:59 +01:00
|
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) wsFolder;
|
|
|
|
name = shared.isVreFolder()?shared.getDisplayName():wsFolder.getName();
|
|
|
|
}else
|
|
|
|
name = wsFolder.getName();
|
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
//MANAGEMENT SPECIAL FOLDER
|
|
|
|
// if(wsFolder.getName().compareTo("MySpecialFolders")==0 && wsFolder.getParent()!=null && wsFolder.getParent().isRoot()){
|
|
|
|
// WorkspaceSharedFolder shared = (WorkspaceSharedFolder) wsFolder;
|
|
|
|
// name = shared.isVreFolder()?shared.getDisplayName():wsFolder.getName();
|
|
|
|
// }else
|
|
|
|
// name = wsFolder.getName();
|
|
|
|
|
|
|
|
FolderModel folder = new FolderModel(wsFolder.getId(), name, parent, true, wsFolder.isShared(), false);
|
|
|
|
folder.setShareable(true);
|
|
|
|
folder.setDescription(wsFolder.getDescription());
|
|
|
|
// folder.setOwner(wsFolder.getOwner());
|
|
|
|
|
|
|
|
|
|
|
|
if(parent != null && parent.isShared()){
|
|
|
|
folder.setShared(true);
|
|
|
|
folder.setShareable(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return folder;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* TODO ********TEMPORARY SOLUTION HL MUST MANAGE SPECIAL FOLDER AS WORKSPACESPECIALFOLDER****
|
|
|
|
* REMOVE THIS METHOD AND ADDING INSTANCE OF AT buildGXTFolderModelItem
|
|
|
|
* @param wsFolder
|
|
|
|
* @param parent
|
|
|
|
* @return
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
|
|
|
public FolderModel buildGXTFolderModelItemHandleSpecialFolder(WorkspaceFolder wsFolder, FileModel parent, String specialFolderName) throws InternalErrorException {
|
|
|
|
|
|
|
|
String name = "";
|
|
|
|
|
|
|
|
//MANAGEMENT SHARED FOLDER NAME
|
|
|
|
if(wsFolder.isShared() && wsFolder.getType().equals(WorkspaceItemType.SHARED_FOLDER)){
|
|
|
|
WorkspaceSharedFolder shared = (WorkspaceSharedFolder) wsFolder;
|
|
|
|
name = shared.isVreFolder()?shared.getDisplayName():wsFolder.getName();
|
|
|
|
|
|
|
|
//MANAGEMENT SPECIAL FOLDER
|
|
|
|
}else if(wsFolder.getName().compareTo("MySpecialFolders")==0 && wsFolder.getParent()!=null && wsFolder.getParent().isRoot()){
|
|
|
|
//MANAGEMENT SPECIAL FOLDER
|
|
|
|
logger.info("MANAGEMENT SPECIAL FOLDER NAME REWRITING AS: "+specialFolderName);
|
|
|
|
if(specialFolderName!=null && !specialFolderName.isEmpty())
|
|
|
|
name = specialFolderName;
|
|
|
|
else
|
|
|
|
name = wsFolder.getName();
|
|
|
|
}else
|
|
|
|
name = wsFolder.getName();
|
|
|
|
|
2014-02-13 18:40:59 +01:00
|
|
|
FolderModel folder = new FolderModel(wsFolder.getId(), name, parent, true, wsFolder.isShared(), false);
|
2013-02-28 14:51:03 +01:00
|
|
|
folder.setShareable(true);
|
2013-06-04 14:38:21 +02:00
|
|
|
folder.setDescription(wsFolder.getDescription());
|
|
|
|
// folder.setOwner(wsFolder.getOwner());
|
|
|
|
|
2013-02-28 14:51:03 +01:00
|
|
|
|
|
|
|
if(parent != null && parent.isShared()){
|
|
|
|
folder.setShared(true);
|
|
|
|
folder.setShareable(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return folder;
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public FileDetailsModel buildGWTWorkspaceFileDetails(WorkspaceItem wsItem, FileModel item) throws InternalErrorException {
|
|
|
|
|
|
|
|
FileDetailsModel fileDetailsModel = new FileDetailsModel(
|
|
|
|
wsItem.getId(),
|
|
|
|
wsItem.getName(),
|
|
|
|
wsItem.getPath(),
|
|
|
|
toDate(wsItem.getCreationTime()),
|
|
|
|
item.getParentFileModel(),
|
|
|
|
0,//size
|
|
|
|
item.isDirectory(),
|
|
|
|
wsItem.getDescription(),
|
|
|
|
toDate(wsItem.getLastModificationTime()),
|
2013-02-25 19:03:53 +01:00
|
|
|
buildGXTInfoContactModel(wsItem.getOwner()),
|
|
|
|
wsItem.isShared());
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
return fileDetailsModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
// public List<FileGridModel> filterListByCategory(List<FileGridModel> listFileGridModel, String category) {
|
|
|
|
//
|
|
|
|
// List<FileGridModel> filteredList = new ArrayList<FileGridModel>();
|
|
|
|
//
|
|
|
|
// logger.trace("Category :" + category);
|
|
|
|
//
|
|
|
|
// for(FileGridModel fileGridModel: listFileGridModel){
|
|
|
|
//
|
|
|
|
// if(fileGridModel.getShortcutCategory()!=null){
|
|
|
|
//
|
|
|
|
//// logger.trace("file GridModel category:" + fileGridModel.getShortcutCategory());
|
|
|
|
//
|
|
|
|
// if(fileGridModel.getShortcutCategory().compareTo(category)==0){
|
|
|
|
// filteredList.add(fileGridModel);
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// }else
|
|
|
|
// logger.trace("file GridModel category null");
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// return filteredList;
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected String getFolderItemTypeCategory(SearchItem item) throws InternalErrorException{
|
|
|
|
|
|
|
|
switch (item.getType()) {
|
|
|
|
|
|
|
|
case FOLDER:
|
|
|
|
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
|
|
|
|
case FOLDER_ITEM:
|
|
|
|
|
|
|
|
SearchFolderItem folderItem = (SearchFolderItem) item;
|
|
|
|
switch(folderItem.getFolderItemType())
|
|
|
|
{
|
|
|
|
case EXTERNAL_IMAGE:
|
|
|
|
return GXTCategoryItemInterface.SMF_IMAGES;
|
|
|
|
case EXTERNAL_FILE:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case EXTERNAL_PDF_FILE:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case EXTERNAL_URL:
|
|
|
|
return GXTCategoryItemInterface.SMF_LINKS;
|
|
|
|
case REPORT_TEMPLATE:
|
|
|
|
return GXTCategoryItemInterface.SMF_REPORTS;
|
|
|
|
case REPORT:
|
|
|
|
return GXTCategoryItemInterface.SMF_REPORTS;
|
|
|
|
case QUERY:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case TIME_SERIES:
|
|
|
|
return GXTCategoryItemInterface.SMF_TIMESERIES;
|
|
|
|
case AQUAMAPS_ITEM:
|
|
|
|
return GXTCategoryItemInterface.SMF_BIODIVERSITY;
|
|
|
|
case PDF_DOCUMENT:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case IMAGE_DOCUMENT:
|
|
|
|
return GXTCategoryItemInterface.SMF_IMAGES;
|
|
|
|
case DOCUMENT:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case URL_DOCUMENT:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case METADATA:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case WORKFLOW_REPORT:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case WORKFLOW_TEMPLATE:
|
|
|
|
return GXTCategoryItemInterface.SMF_DOCUMENTS;
|
|
|
|
case EXTERNAL_RESOURCE_LINK:
|
|
|
|
return GXTCategoryItemInterface.SMF_LINKS;
|
|
|
|
default:
|
|
|
|
return GXTCategoryItemInterface.SMF_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
logger.error("gxt conversion return null for item "+item.getName());
|
|
|
|
return GXTCategoryItemInterface.SMF_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<FileGridModel> filterListFileGridModelItemByCategory(List<SearchItem> listSearchItem, String category) throws InternalErrorException {
|
|
|
|
|
|
|
|
List<FileGridModel> filteredList = new ArrayList<FileGridModel>();
|
|
|
|
|
|
|
|
logger.trace("filterListFileGridModelItemByCategory - Category:" + category + "listSearchItem size " + listSearchItem.size());
|
|
|
|
//FOR DEBUG
|
|
|
|
// System.out.println("filterListFileGridModelItemByCategory - Category:" + category + "listSearchItem size " + listSearchItem.size());
|
|
|
|
|
|
|
|
for(SearchItem searchItem: listSearchItem){
|
|
|
|
|
|
|
|
logger.trace("wsItem: " + searchItem.getName());
|
|
|
|
// FOR DEBUG
|
|
|
|
// System.out.println("wsItem: " + searchItem.getName());
|
|
|
|
|
|
|
|
if(category.equals(getFolderItemTypeCategory(searchItem))){
|
|
|
|
|
|
|
|
filteredList.add(buildGXTFileGridModelItemForSearch(searchItem,null));
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return filteredList;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public List<SmartFolderModel> buildGXTListSmartFolderModel(List<WorkspaceSmartFolder> listWorkspaceSmartFolder) throws InternalErrorException {
|
|
|
|
List<SmartFolderModel> listSmartFolder = new ArrayList<SmartFolderModel>();
|
|
|
|
|
|
|
|
for(WorkspaceSmartFolder workspaceFolder : listWorkspaceSmartFolder)
|
|
|
|
listSmartFolder.add(buildGXTSmartFolderModel(workspaceFolder, ""));
|
|
|
|
|
|
|
|
return listSmartFolder;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public SmartFolderModel buildGXTSmartFolderModel(WorkspaceSmartFolder wsFolder, String query) throws InternalErrorException {
|
|
|
|
|
|
|
|
SmartFolderModel smartFolderModel = new SmartFolderModel(
|
|
|
|
wsFolder.getId(),
|
|
|
|
wsFolder.getName(),
|
|
|
|
query);
|
|
|
|
|
|
|
|
logger.trace("in return SmartFolder: " + smartFolderModel.getIdentifier() + " " + smartFolderModel.getName() + " " + smartFolderModel.getQuery());
|
|
|
|
return smartFolderModel;
|
|
|
|
}
|
|
|
|
|
2013-03-27 17:30:37 +01:00
|
|
|
public List<ScopeModel> buildGXTListScopeModel(List<String> listFilteredScopes, Map<String, String> mapPortalScopes) {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
List<ScopeModel> listScopeModel = new ArrayList<ScopeModel>();
|
|
|
|
|
2013-03-27 17:30:37 +01:00
|
|
|
// listScopeModel.add(AllScope.getScopeModel());
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2013-03-27 17:30:37 +01:00
|
|
|
for(String scope: listFilteredScopes)
|
|
|
|
listScopeModel.add(new ScopeModel(mapPortalScopes.get(scope),scope));
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
// listScopeModel.add(new ScopeModel("1", "Aquamaps"));
|
|
|
|
// listScopeModel.add(new ScopeModel("2", "VTI"));
|
|
|
|
// listScopeModel.add(new ScopeModel("3", "TimeSeries"));
|
|
|
|
|
|
|
|
return listScopeModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-03-10 17:33:33 +01:00
|
|
|
public List<InfoContactModel> buildGXTListContactsModelFromUserModel(List<UserModel> listUsers) throws InternalErrorException {
|
2013-02-06 15:40:17 +01:00
|
|
|
|
|
|
|
List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
|
|
|
|
|
2013-10-02 18:20:54 +02:00
|
|
|
if(listUsers==null)
|
|
|
|
return listContactsModel;
|
|
|
|
|
2013-10-03 14:45:25 +02:00
|
|
|
logger.trace("List<UserModel> size returned from Portal VO is: "+ listUsers.size());
|
2013-10-02 18:20:54 +02:00
|
|
|
|
2013-10-02 17:16:10 +02:00
|
|
|
logger.trace("Building list contact model list user model");
|
2013-10-02 15:39:39 +02:00
|
|
|
for (UserModel userModel : listUsers) {
|
2013-10-02 18:20:54 +02:00
|
|
|
String fullName = userModel.getFullname();
|
2013-06-12 16:53:19 +02:00
|
|
|
|
|
|
|
if(fullName!=null && !fullName.isEmpty())
|
2014-03-10 17:33:33 +01:00
|
|
|
listContactsModel.add(new InfoContactModel(userModel.getUserId()+"", userModel.getScreenName(), fullName, false));
|
2013-06-12 16:53:19 +02:00
|
|
|
else
|
2014-05-09 17:48:30 +02:00
|
|
|
logger.trace("buildGXTListContactsModel is not returning user: "+userModel.getScreenName()+ "because name is null or empty");
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
2013-10-02 17:16:10 +02:00
|
|
|
logger.trace("List contact model completed, return " +listContactsModel.size()+" contacts");
|
2013-02-14 15:06:34 +01:00
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
return listContactsModel;
|
|
|
|
}
|
|
|
|
|
2014-03-10 17:33:33 +01:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param list
|
|
|
|
* @return
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
|
|
|
public List<InfoContactModel> buildGXTListContactsModelFromGcubeGroup(List<GCubeGroup> list) throws InternalErrorException {
|
|
|
|
|
|
|
|
List<InfoContactModel> listContactsModel = new ArrayList<InfoContactModel>();
|
|
|
|
|
|
|
|
if(list==null)
|
|
|
|
return listContactsModel;
|
|
|
|
|
|
|
|
logger.trace("List<GCubeGroup> size returned from GcubeGroup is: "+ list.size());
|
|
|
|
|
|
|
|
logger.trace("Building list contact model...");
|
2014-05-28 18:04:31 +02:00
|
|
|
|
|
|
|
for (GCubeGroup group : list){
|
|
|
|
try{
|
2014-05-29 12:19:36 +02:00
|
|
|
String groupDN = group.getDisplayName();
|
|
|
|
|
|
|
|
if(groupDN==null || groupDN.isEmpty())
|
|
|
|
groupDN = group.getName();
|
|
|
|
|
2014-05-29 12:44:34 +02:00
|
|
|
if(group.getName()== null || group.getName().isEmpty())
|
|
|
|
logger.warn("Skipping group with null or empty name "+group);
|
|
|
|
else{
|
|
|
|
InfoContactModel contact = new InfoContactModel(group.getName(), group.getName(), groupDN, true);
|
|
|
|
logger.trace("Adding group "+contact);
|
|
|
|
listContactsModel.add(contact);
|
|
|
|
}
|
2014-05-28 18:04:31 +02:00
|
|
|
}catch (InternalErrorException e) {
|
|
|
|
logger.warn("Dispaly name is not available to group "+group);
|
|
|
|
logger.warn("Adding get name property "+group.getName());
|
2014-05-29 12:44:34 +02:00
|
|
|
|
|
|
|
if(group.getName()== null || group.getName().isEmpty())
|
|
|
|
logger.warn("Skipping group with null or empty name "+group);
|
|
|
|
else
|
|
|
|
listContactsModel.add(new InfoContactModel(group.getName(), group.getName(), group.getName(), true));
|
2014-05-28 18:04:31 +02:00
|
|
|
}
|
2014-03-10 17:33:33 +01:00
|
|
|
}
|
2014-05-28 18:04:31 +02:00
|
|
|
|
2014-03-10 17:33:33 +01:00
|
|
|
logger.trace("List GCubeGroup contact model completed, return " +listContactsModel.size()+" contacts");
|
|
|
|
|
|
|
|
return listContactsModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-06 15:40:17 +01:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param listContactsModel
|
|
|
|
* @return list of portal logins
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
|
|
|
public List<String> buildListLoginFromContanctModel(List<InfoContactModel> listContactsModel) throws InternalErrorException {
|
|
|
|
|
|
|
|
List<String> listPortalLogin = new ArrayList<String>();
|
|
|
|
|
|
|
|
for(InfoContactModel contact: listContactsModel){
|
|
|
|
listPortalLogin.add(contact.getLogin());
|
|
|
|
|
|
|
|
}
|
|
|
|
return listPortalLogin;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public List<MessageModel> buildGXTListMessageModelForGrid(List<WorkspaceMessage> listMessages, String typeMessages) throws InternalErrorException {
|
|
|
|
|
|
|
|
List<MessageModel> listMessageModel = new ArrayList<MessageModel>();
|
|
|
|
|
|
|
|
|
|
|
|
for(WorkspaceMessage mess: listMessages){
|
|
|
|
List<WorkspaceItem> listAttachs = mess.getAttachments();
|
|
|
|
List<String> listAttachsNames = new ArrayList<String>();
|
|
|
|
|
|
|
|
logger.trace("IN SERVER MESSAGE TYPE: " +typeMessages);
|
|
|
|
logger.trace("subject " + mess.getSubject());
|
|
|
|
|
|
|
|
if(listAttachs!=null){
|
|
|
|
for(WorkspaceItem attach: listAttachs){
|
|
|
|
listAttachsNames.add(attach.getName());
|
|
|
|
logger.trace("Received attach: "+ attach.getName() + " " +attach.getId());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
listMessageModel.add(new MessageModel(mess.getId(), mess.getSubject(), buildGXTInfoContactModel(mess.getSender()), toDate(mess.getSendTime()), listAttachsNames, typeMessages, mess.isRead()));
|
|
|
|
|
|
|
|
}
|
|
|
|
// listMessageModel.add(new MessageModel("1", "subject", new InfoContactModel("1", "Federico"), "2001.07.04 at 12:08:56", 5));
|
|
|
|
// listMessageModel.add(new MessageModel("2", "subject 2", new InfoContactModel("1", "Federico"), "2005.07.04 at 12:08:56", 2));
|
|
|
|
// listMessageModel.add(new MessageModel("3", "subject 3", new InfoContactModel("3", "Francesco"), "2001.07.04 at 15:08:56", 3));
|
|
|
|
|
|
|
|
return listMessageModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
public MessageModel buildGXTMessageModel(WorkspaceMessage mess, List<WorkspaceItem> listWorkspaceItems, String messageType) throws InternalErrorException {
|
|
|
|
|
|
|
|
|
|
|
|
List<FileModel> listAttachs = buildGXTListFileModelItemForAttachs(listWorkspaceItems);
|
|
|
|
|
|
|
|
// List<InfoContactModel> listContacts = new ArrayList<InfoContactModel>();
|
|
|
|
|
|
|
|
// mess.getAddresses();
|
|
|
|
// listContacts.add(new InfoContactModel("1", "Empty"));
|
|
|
|
|
|
|
|
return new MessageModel(mess.getId(), mess.getSubject(), buildGXTInfoContactModel(mess.getSender()), toDate(mess.getSendTime()), mess.getBody(), listAttachs, mess.getAddresses(), messageType, mess.isRead());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-25 19:03:53 +01:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param user
|
|
|
|
* @return InfoContactModel
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
|
|
|
public InfoContactModel buildGXTInfoContactModel(User user) throws InternalErrorException{
|
2013-02-06 15:40:17 +01:00
|
|
|
|
2013-02-25 19:03:53 +01:00
|
|
|
if(user!=null)
|
2014-03-10 17:33:33 +01:00
|
|
|
return new InfoContactModel(user.getId(), user.getPortalLogin(), UserUtil.getUserFullName(user.getPortalLogin()), false);
|
2013-02-25 19:03:53 +01:00
|
|
|
|
|
|
|
return new InfoContactModel();
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// private static float counter = 0;
|
|
|
|
|
|
|
|
public List<BulkCreatorModel> buildGXTListBulkCreatorModel(List<FolderBulkCreator> listFBC) throws InternalErrorException {
|
|
|
|
|
|
|
|
List<BulkCreatorModel> listBulkCreatorModel = new ArrayList<BulkCreatorModel>();
|
|
|
|
|
|
|
|
for (FolderBulkCreator item : listFBC){
|
|
|
|
|
|
|
|
BulkCreatorModel bulk;
|
|
|
|
|
|
|
|
if(item.getStatus()<1)
|
|
|
|
bulk = new BulkCreatorModel(item.getId(), item.getDestinationFolder().getName(), item.getStatus(), BulkCreatorModel.ONGOING, item.getNumberOfRequests(), item.getFailures());
|
|
|
|
else{//status = 1
|
|
|
|
|
|
|
|
int failures = item.getFailures();
|
|
|
|
|
|
|
|
if(failures==0)
|
|
|
|
bulk = new BulkCreatorModel(item.getId(), item.getDestinationFolder().getName(), item.getStatus(), BulkCreatorModel.COMPLETED, item.getNumberOfRequests(), item.getFailures());
|
|
|
|
else
|
|
|
|
if(failures<item.getNumberOfRequests())
|
|
|
|
bulk = new BulkCreatorModel(item.getId(), item.getDestinationFolder().getName(), item.getStatus(), BulkCreatorModel.FAILED, item.getNumberOfRequests(), item.getFailures());
|
|
|
|
else
|
|
|
|
bulk = new BulkCreatorModel(item.getId(), item.getDestinationFolder().getName(), item.getStatus(), BulkCreatorModel.FAILED, item.getNumberOfRequests(), item.getFailures());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
listBulkCreatorModel.add(bulk);
|
|
|
|
}
|
|
|
|
|
|
|
|
// //TODO EXAMPLES
|
|
|
|
//
|
|
|
|
// if(counter < 0.4){
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("1", "Test 1", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("2", "Test 2", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("3", "Test 3", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("4", "Test 4", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("5", "Test 5", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("6", "Test 6", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// else{
|
|
|
|
//
|
|
|
|
//// float perc = (float) 0.8;
|
|
|
|
//
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("1", "Test 1", (float) 1, BulkCreatorModel.FAILED, 5, 3));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("2", "Test 2", (float) 1, BulkCreatorModel.FAILED, 5, 4));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("3", "Test 3", counter, BulkCreatorModel.COMPLETED, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("4", "Test 4", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("5", "Test 5", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// listBulkCreatorModel.add(new BulkCreatorModel("6", "Test 6", counter, BulkCreatorModel.ONGOING, 5, 0));
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// counter+=0.2;
|
|
|
|
//
|
|
|
|
// if(counter>1)
|
|
|
|
// counter=0;
|
|
|
|
|
|
|
|
return listBulkCreatorModel;
|
|
|
|
}
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param accouting
|
|
|
|
*/
|
|
|
|
public List<GxtAccountingField> buildGXTAccountingItem(List<AccountingEntry> accoutings, GxtAccountingEntryType gxtEntryType) {
|
|
|
|
|
|
|
|
List<GxtAccountingField> listAccFields = new ArrayList<GxtAccountingField>();
|
|
|
|
|
|
|
|
if(accoutings!=null){
|
|
|
|
logger.trace("accoutings size "+accoutings.size()+ "converting");
|
|
|
|
|
|
|
|
for (AccountingEntry accountingEntry : accoutings) {
|
|
|
|
|
|
|
|
GxtAccountingField af = new GxtAccountingField();
|
|
|
|
|
|
|
|
InfoContactModel user = buildGxtInfoContactFromPortalLogin(accountingEntry.getUser());
|
|
|
|
|
|
|
|
af.setUser(user);
|
|
|
|
af.setDate(toDate(accountingEntry.getDate()));
|
|
|
|
|
|
|
|
switch (accountingEntry.getEntryType()) {
|
|
|
|
|
2013-05-27 18:25:10 +02:00
|
|
|
|
|
|
|
case CREATE:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.CREATE)){
|
2013-07-24 16:44:26 +02:00
|
|
|
AccountingEntryCreate create = (AccountingEntryCreate) accountingEntry;
|
2013-05-27 18:25:10 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.CREATE);
|
2013-07-24 16:44:26 +02:00
|
|
|
|
|
|
|
// af.setDescription(GxtAccountingEntryType.CREATE.getName() + " by "+user.getName());
|
2013-07-24 17:59:20 +02:00
|
|
|
String msg = "";
|
|
|
|
if(create.getItemName()==null || create.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.CREATE.getId() + " by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = create.getItemName() + " " + GxtAccountingEntryType.CREATE.getName() + " by "+user.getName();
|
2013-07-24 16:44:26 +02:00
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
af.setDescription(msg);
|
2013-05-27 18:25:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
case READ:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.READ)){
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-07-24 16:44:26 +02:00
|
|
|
AccountingEntryRead read = (AccountingEntryRead) accountingEntry;
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.READ);
|
2013-07-24 16:44:26 +02:00
|
|
|
|
|
|
|
// af.setDescription(GxtAccountingEntryType.READ.getName() + " by "+user.getName());
|
2013-07-24 17:59:20 +02:00
|
|
|
af.setDescription(read.getItemName() + " " + GxtAccountingEntryType.READ.getName() + " by "+user.getName());
|
|
|
|
|
|
|
|
String msg = "";
|
|
|
|
if(read.getItemName()==null || read.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.READ.getId() + " by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = read.getItemName() + " " + GxtAccountingEntryType.READ.getName() + " by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CUT:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.CUT)){
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
af.setOperation(GxtAccountingEntryType.CUT);
|
|
|
|
|
|
|
|
AccountingEntryCut cut = (AccountingEntryCut) accountingEntry;
|
2013-07-23 20:05:08 +02:00
|
|
|
|
2013-07-24 16:44:26 +02:00
|
|
|
// af.setDescription(GxtAccountingEntryType.CUT.getName()+ " "+cut.getItemName()+" by "+user.getName());
|
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
String msg = "";
|
|
|
|
if(cut.getItemName()==null || cut.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.CUT.getName() +" by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = cut.getItemName()+" "+GxtAccountingEntryType.CUT.getName() +" by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
|
|
|
|
// af.setDescription(cut.getItemName()+" "+GxtAccountingEntryType.CUT.getName() +" by "+user.getName());
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PASTE:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.PASTE)){
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
af.setOperation(GxtAccountingEntryType.PASTE);
|
|
|
|
|
|
|
|
AccountingEntryPaste paste = (AccountingEntryPaste) accountingEntry;
|
2013-07-24 17:59:20 +02:00
|
|
|
|
2013-07-23 20:05:08 +02:00
|
|
|
af.setDescription(GxtAccountingEntryType.PASTE.getName() + " from "+paste.getFromPath()+" by "+user.getName());
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case REMOVAL:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.REMOVE)){
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-05-27 12:21:16 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.REMOVE);
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
AccountingEntryRemoval rem = (AccountingEntryRemoval) accountingEntry;
|
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
String msg = "";
|
|
|
|
if(rem.getItemName()==null || rem.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.REMOVE.getName() +" by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = rem.getItemName() + " "+GxtAccountingEntryType.REMOVE.getName() +" by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
|
2013-07-24 16:44:26 +02:00
|
|
|
// af.setDescription(GxtAccountingEntryType.REMOVE.getName() + " "+rem.getItemName()+" by "+user.getName());
|
2013-07-24 17:59:20 +02:00
|
|
|
// af.setDescription(rem.getItemName() + " "+GxtAccountingEntryType.REMOVE.getName() +" by "+user.getName());
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RENAMING:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.RENAME)){
|
2013-05-23 19:03:43 +02:00
|
|
|
|
2013-05-27 12:21:16 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.RENAME);
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
AccountingEntryRenaming ren = (AccountingEntryRenaming) accountingEntry;
|
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
String msg = "";
|
|
|
|
if(ren.getOldItemName()==null || ren.getOldItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.RENAME.getName()+ " by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = ren.getOldItemName() +" "+GxtAccountingEntryType.RENAME.getName()+ " by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
|
2013-07-24 16:44:26 +02:00
|
|
|
// af.setDescription(GxtAccountingEntryType.RENAME.getName()+" from "+ren.getOldItemName() + " by "+user.getName());
|
2013-07-24 17:59:20 +02:00
|
|
|
// af.setDescription(ren.getOldItemName() +" "+GxtAccountingEntryType.RENAME.getName()+ " by "+user.getName());
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
|
|
|
break;
|
2013-07-23 14:24:17 +02:00
|
|
|
|
|
|
|
case ADD:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.ADD)){
|
2013-07-23 14:24:17 +02:00
|
|
|
|
2013-07-23 20:05:08 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.ADD);
|
2013-07-23 14:24:17 +02:00
|
|
|
|
|
|
|
AccountingEntryAdd acc = (AccountingEntryAdd) accountingEntry;
|
2013-07-24 17:59:20 +02:00
|
|
|
|
|
|
|
String msg = "";
|
|
|
|
if(acc.getItemName()==null || acc.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.ADD.getName()+ " by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = acc.getItemName() + " "+GxtAccountingEntryType.ADD.getName()+ " by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
2013-07-23 14:24:17 +02:00
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
// af.setDescription(acc.getItemName() + " "+GxtAccountingEntryType.ADD.getName()+ " by "+user.getName());
|
2013-07-23 14:24:17 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UPDATE:
|
|
|
|
|
2013-08-28 14:36:38 +02:00
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.UPDATE)){
|
2013-07-23 14:24:17 +02:00
|
|
|
|
2013-07-23 20:05:08 +02:00
|
|
|
af.setOperation(GxtAccountingEntryType.UPDATE);
|
2013-07-23 14:24:17 +02:00
|
|
|
|
2013-07-23 20:05:08 +02:00
|
|
|
AccountingEntryUpdate acc = (AccountingEntryUpdate) accountingEntry;
|
2013-07-24 17:59:20 +02:00
|
|
|
|
|
|
|
String msg = "";
|
|
|
|
if(acc.getItemName()==null || acc.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.UPDATE.getName()+" by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = acc.getItemName() +" "+GxtAccountingEntryType.UPDATE.getName()+" by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
2013-07-23 14:24:17 +02:00
|
|
|
|
2013-07-24 16:44:26 +02:00
|
|
|
// af.setDescription(GxtAccountingEntryType.UPDATE.getName()+ " "+acc.getItemName() +" by "+user.getName());
|
2013-07-24 17:59:20 +02:00
|
|
|
// af.setDescription(acc.getItemName() +" "+GxtAccountingEntryType.UPDATE.getName()+" by "+user.getName());
|
2013-07-23 14:24:17 +02:00
|
|
|
}
|
|
|
|
break;
|
2013-09-02 16:01:00 +02:00
|
|
|
|
|
|
|
case SHARE:
|
|
|
|
|
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.SHARE)){
|
|
|
|
|
|
|
|
af.setOperation(GxtAccountingEntryType.SHARE);
|
|
|
|
|
|
|
|
AccountingEntryShare acc = (AccountingEntryShare) accountingEntry;
|
2013-09-02 18:16:37 +02:00
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
// List<String> listContacts = new ArrayList<String>();
|
2013-09-02 18:16:37 +02:00
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
// if(acc.getMembers()!=null && acc.getMembers().size()>0){
|
|
|
|
//
|
|
|
|
// listContacts = acc.getMembers();
|
|
|
|
// }
|
2013-09-02 18:16:37 +02:00
|
|
|
|
2013-09-02 16:01:00 +02:00
|
|
|
|
|
|
|
String msg = "";
|
|
|
|
if(acc.getItemName()==null || acc.getItemName().isEmpty())
|
2013-09-02 18:16:37 +02:00
|
|
|
msg = user.getName() + " "+GxtAccountingEntryType.SHARE.getName()+ " workspace folder";
|
|
|
|
// msg = GxtAccountingEntryType.SHARE.getName()+" by "+user.getName();
|
2013-09-02 16:01:00 +02:00
|
|
|
else
|
2013-09-02 18:16:37 +02:00
|
|
|
msg = user.getName() + " "+GxtAccountingEntryType.SHARE.getName()+ " workspace folder "+acc.getItemName();
|
|
|
|
// msg = acc.getItemName() +" "+GxtAccountingEntryType.SHARE.getName()+" by "+user.getName();
|
|
|
|
|
|
|
|
|
2014-03-17 14:43:06 +01:00
|
|
|
if(acc.getMembers()!=null && acc.getMembers().size()>0){
|
2013-09-02 18:16:37 +02:00
|
|
|
|
|
|
|
msg+=" with "+UserUtil.separateFullNameToCommaForPortalLogin(acc.getMembers());
|
|
|
|
}
|
2013-09-02 16:01:00 +02:00
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UNSHARE:
|
|
|
|
|
|
|
|
if(gxtEntryType==null || gxtEntryType.equals(GxtAccountingEntryType.ALL) || gxtEntryType.equals(GxtAccountingEntryType.ALLWITHOUTREAD) || gxtEntryType.equals(GxtAccountingEntryType.UNSHARE)){
|
|
|
|
|
|
|
|
af.setOperation(GxtAccountingEntryType.UNSHARE);
|
|
|
|
|
|
|
|
AccountingEntryUnshare acc = (AccountingEntryUnshare) accountingEntry;
|
|
|
|
|
|
|
|
String msg = "";
|
|
|
|
if(acc.getItemName()==null || acc.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.UNSHARE.getName()+" by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = acc.getItemName() +" "+GxtAccountingEntryType.UNSHARE.getName()+" by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
}
|
2013-09-02 18:16:37 +02:00
|
|
|
|
2013-05-23 19:03:43 +02:00
|
|
|
listAccFields.add(af);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
logger.trace("get accounting readers converting completed - returning size "+listAccFields.size());
|
|
|
|
|
|
|
|
return listAccFields;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param readers
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public List<GxtAccountingField> buildGXTAccountingItemFromReaders(List<AccountingEntryRead> readers) {
|
|
|
|
|
|
|
|
List<GxtAccountingField> listAccFields = new ArrayList<GxtAccountingField>();
|
|
|
|
|
|
|
|
if(readers!=null){
|
|
|
|
|
|
|
|
for (AccountingEntryRead accReader : readers) {
|
|
|
|
|
|
|
|
GxtAccountingField af = new GxtAccountingField();
|
|
|
|
|
|
|
|
InfoContactModel user = buildGxtInfoContactFromPortalLogin(accReader.getUser());
|
|
|
|
|
|
|
|
af.setUser(user);
|
|
|
|
af.setDate(toDate(accReader.getDate()));
|
|
|
|
|
|
|
|
af.setOperation(GxtAccountingEntryType.READ);
|
2013-07-24 16:44:26 +02:00
|
|
|
// af.setDescription(GxtAccountingEntryType.READ.getName() +" by "+user.getName());
|
|
|
|
|
2013-07-24 17:59:20 +02:00
|
|
|
String msg = "";
|
|
|
|
if(accReader.getItemName()==null || accReader.getItemName().isEmpty())
|
|
|
|
msg = GxtAccountingEntryType.READ.getName() + " by "+user.getName();
|
|
|
|
else
|
|
|
|
msg = accReader.getItemName() + " " + GxtAccountingEntryType.READ.getName() + " by "+user.getName();
|
|
|
|
|
|
|
|
af.setDescription(msg);
|
|
|
|
|
|
|
|
// af.setDescription(accReader.getItemName() + " " + GxtAccountingEntryType.READ.getName() + " by "+user.getName());
|
2013-05-23 19:03:43 +02:00
|
|
|
|
|
|
|
listAccFields.add(af);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return listAccFields;
|
|
|
|
}
|
2013-09-03 15:49:22 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param infoContactModel
|
|
|
|
*/
|
|
|
|
public void setUserLogged(InfoContactModel infoContactModel) {
|
|
|
|
this.userLogged = infoContactModel;
|
|
|
|
}
|
2014-02-17 15:56:42 +01:00
|
|
|
|
|
|
|
|
|
|
|
public List<WorkspaceACL> getWorkspaceACLFromACLs(List<ACLType> types) throws Exception{
|
|
|
|
|
|
|
|
List<WorkspaceACL> acls = new ArrayList<WorkspaceACL>();
|
|
|
|
|
|
|
|
for (ACLType acl : types) {
|
|
|
|
|
|
|
|
switch (acl) {
|
|
|
|
case ADMINISTRATOR:
|
2014-02-18 17:15:20 +01:00
|
|
|
acls.add(new WorkspaceACL(acl.toString(), "Admin", false, USER_TYPE.ADMINISTRATOR, ""));
|
2014-02-17 15:56:42 +01:00
|
|
|
break;
|
|
|
|
case READ_ONLY:
|
|
|
|
acls.add(new WorkspaceACL(acl.toString(), "Read Only", false, USER_TYPE.OTHER, "Users can read any file but cannot update/delete"));
|
|
|
|
break;
|
|
|
|
case WRITE_OWNER:
|
|
|
|
acls.add(new WorkspaceACL(acl.toString(), "Write Own", true, USER_TYPE.OTHER, "Users can update/delete only their files"));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WRITE_ALL:
|
|
|
|
acls.add(new WorkspaceACL(acl.toString(), "Write Any", false, USER_TYPE.OTHER,"Any user can update/delete any file"));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2014-10-27 15:45:53 +01:00
|
|
|
// acls.add(new WorkspaceACL(acl.toString(), acl.toString(), false, USER_TYPE.OTHER, ""));
|
|
|
|
// break;
|
2014-02-17 15:56:42 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(acls.size()==0)
|
|
|
|
throw new Exception("No ACLs rules found!");
|
|
|
|
|
2014-03-17 17:59:06 +01:00
|
|
|
logger.trace("returning acls: "+acls);
|
|
|
|
|
2014-02-17 15:56:42 +01:00
|
|
|
return acls;
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<FileTrashedModel> buildGXTListTrashContent(WorkspaceTrashFolder trash) throws Exception
|
|
|
|
{
|
2014-05-13 11:10:54 +02:00
|
|
|
List<WorkspaceTrashItem> trashContent = trash.listTrashItems();
|
|
|
|
|
|
|
|
logger.info("Converting trash content, size is: "+ trashContent.size());
|
2014-02-17 15:56:42 +01:00
|
|
|
|
|
|
|
List<FileTrashedModel> listFileModel = new ArrayList<FileTrashedModel>();
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
for (WorkspaceTrashItem trashedItem : trashContent)
|
|
|
|
try{
|
|
|
|
FileTrashedModel cti = buildGXTTrashModelItem(trashedItem);
|
|
|
|
listFileModel.add(cti);
|
|
|
|
}catch (Exception e) {
|
|
|
|
logger.warn("Error in server buildGXTListTrashContent, skipping conversion of trashedItem", e);
|
|
|
|
}
|
2014-02-17 15:56:42 +01:00
|
|
|
} catch (Exception e) {
|
|
|
|
logger.error("Error in server buildGXTListTrashContent", e);
|
|
|
|
String error = ConstantsExplorer.SERVER_ERROR +" get Trash content. "+e.getMessage();
|
|
|
|
throw new Exception(error);
|
|
|
|
}
|
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
logger.info("Returning trash content as FileTrashedModel, size is: "+ trashContent.size());
|
|
|
|
|
2014-02-17 15:56:42 +01:00
|
|
|
return listFileModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param trashedItem
|
|
|
|
* @return
|
|
|
|
* @throws InternalErrorException
|
|
|
|
*/
|
2014-02-17 15:56:42 +01:00
|
|
|
public FileTrashedModel buildGXTTrashModelItem(WorkspaceTrashItem trashedItem) throws InternalErrorException{
|
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
FileTrashedModel fileTrashModel = new FileTrashedModel();
|
|
|
|
fileTrashModel.setName(trashedItem.getName());
|
2014-02-17 15:56:42 +01:00
|
|
|
|
2014-05-14 12:14:07 +02:00
|
|
|
fileTrashModel.setIdentifier(trashedItem.getId()); //TODO
|
2014-05-13 17:46:06 +02:00
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
//SETTING PARENT
|
|
|
|
FileModel oldParent = new FileModel(trashedItem.getOriginalParentId(), "", true);
|
2014-05-13 17:46:06 +02:00
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
fileTrashModel.setOrginalPath(trashedItem.getDeletedFrom());
|
|
|
|
fileTrashModel.setParentFileModel(oldParent);
|
|
|
|
|
|
|
|
//SETTING DELETED BY
|
|
|
|
InfoContactModel deleteUser = buildGxtInfoContactFromPortalLogin(trashedItem.getDeletedBy());
|
|
|
|
fileTrashModel.setDeleteUser(deleteUser);
|
2014-04-03 11:14:00 +02:00
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
//SETTING MIME TYPE
|
|
|
|
fileTrashModel.setType(trashedItem.getMimeType());
|
|
|
|
|
|
|
|
//SETTING IS DIRECTORY
|
|
|
|
fileTrashModel.setIsDirectory(trashedItem.isFolder());
|
|
|
|
|
|
|
|
//SETTING DELETE DATE
|
|
|
|
fileTrashModel.setDeleteDate(toDate(trashedItem.getDeletedTime()));
|
|
|
|
|
|
|
|
fileTrashModel.setShared(false);
|
2014-02-17 15:56:42 +01:00
|
|
|
|
2014-05-13 11:10:54 +02:00
|
|
|
logger.info("Converting return trash item: "+fileTrashModel);
|
|
|
|
|
2014-02-17 15:56:42 +01:00
|
|
|
return fileTrashModel;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public FileTrashedModel buildGXTTrashModelItemById(String itemId, WorkspaceTrashFolder trash) throws InternalErrorException{
|
|
|
|
return null;
|
|
|
|
|
|
|
|
}
|
2014-02-18 14:40:19 +01:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param aclOwner
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public String getFormattedHtmlACLFromACLs(Map<ACLType, List<String>> aclOwner) {
|
|
|
|
|
|
|
|
String html = "<div style=\"width: 100%; text-align:left; font-size: 10px;\">";
|
|
|
|
|
2014-07-17 11:11:35 +02:00
|
|
|
logger.trace("Formatting "+aclOwner.size() +" ACL/s");
|
|
|
|
|
2014-02-18 14:40:19 +01:00
|
|
|
for (ACLType type : aclOwner.keySet()) {
|
|
|
|
List<String> listLogins = aclOwner.get(type);
|
2014-07-17 11:11:35 +02:00
|
|
|
|
2014-02-18 14:40:19 +01:00
|
|
|
html+="<span style=\"font-weight:bold; padding-top: 5px;\">"+type+": </span>";
|
|
|
|
html+="<span style=\"font-weight:normal;\">";
|
|
|
|
for (String login : listLogins) {
|
2014-07-17 11:11:35 +02:00
|
|
|
logger.trace("Adding login "+login);
|
2014-02-18 14:40:19 +01:00
|
|
|
String fullName = UserUtil.getUserFullName(login);
|
|
|
|
if(fullName!=null && !fullName.isEmpty())
|
|
|
|
html+=fullName+"; ";
|
|
|
|
else
|
|
|
|
html+=login+"; ";
|
|
|
|
}
|
2014-02-19 15:07:50 +01:00
|
|
|
html+="</span><br/>";
|
2014-02-18 14:40:19 +01:00
|
|
|
}
|
|
|
|
html+="</div>";
|
|
|
|
|
|
|
|
|
|
|
|
return html;
|
|
|
|
}
|
2014-10-31 17:27:52 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* returns dynamically the formated size
|
|
|
|
* @param size
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public static String formatFileSize(long size) {
|
|
|
|
String formattedSize = null;
|
|
|
|
|
|
|
|
double b = size;
|
|
|
|
double k = size/1024.0;
|
|
|
|
double m = ((size/1024.0)/1024.0);
|
|
|
|
double g = (((size/1024.0)/1024.0)/1024.0);
|
|
|
|
double t = ((((size/1024.0)/1024.0)/1024.0)/1024.0);
|
|
|
|
|
|
|
|
DecimalFormat dec = new DecimalFormat("0.00");
|
|
|
|
|
|
|
|
if ( t>1 ) {
|
|
|
|
formattedSize = dec.format(t).concat(" TB");
|
|
|
|
} else if ( g>1 ) {
|
|
|
|
formattedSize = dec.format(g).concat(" GB");
|
|
|
|
} else if ( m>1 ) {
|
|
|
|
formattedSize = dec.format(m).concat(" MB");
|
|
|
|
} else if ( k>1 ) {
|
|
|
|
formattedSize = dec.format(k).concat(" KB");
|
|
|
|
} else {
|
|
|
|
formattedSize = dec.format(b).concat(" Bytes");
|
|
|
|
}
|
|
|
|
|
|
|
|
return formattedSize;
|
|
|
|
}
|
2014-11-04 18:20:06 +01:00
|
|
|
|
|
|
|
public String getItemDescriptionForTypeById(WorkspaceItem item) throws Exception {
|
|
|
|
|
|
|
|
if(item==null)
|
|
|
|
throw new Exception("The item is null");
|
|
|
|
|
|
|
|
logger.info("Getting ItemDescriptionById: "+item.getId());
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
switch (item.getType()) {
|
|
|
|
|
|
|
|
case FOLDER:{
|
|
|
|
WorkspaceFolder theFolder = (WorkspaceFolder) item;
|
|
|
|
return theFolder.getDescription();
|
|
|
|
}
|
|
|
|
case SHARED_FOLDER:{
|
|
|
|
WorkspaceSharedFolder theFolder = (WorkspaceSharedFolder) item;
|
|
|
|
return theFolder.getDescription();
|
|
|
|
}
|
|
|
|
case GCUBE_ITEM:{
|
|
|
|
|
|
|
|
GCubeItem theGcubeItem = (GCubeItem) item;
|
|
|
|
return theGcubeItem.getDescription();
|
|
|
|
}
|
|
|
|
case SMART_FOLDER:{
|
|
|
|
WorkspaceSmartFolder theFolder = (WorkspaceSmartFolder) item;
|
|
|
|
return theFolder.getDescription();
|
|
|
|
}
|
|
|
|
|
|
|
|
case TRASH_FOLDER:{
|
|
|
|
WorkspaceTrashFolder theFolder = (WorkspaceTrashFolder) item;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
case TRASH_ITEM:{
|
|
|
|
WorkspaceTrashItem tItem = (WorkspaceTrashItem) item;
|
|
|
|
return tItem.getDescription();
|
|
|
|
}
|
|
|
|
|
|
|
|
default:{ //IS AN ITEM
|
|
|
|
return item.getDescription();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} catch (Exception e) {
|
|
|
|
logger.error("Error in server ItemDescriptionForTypeById: ", e);
|
|
|
|
String error = ConstantsExplorer.SERVER_ERROR +" getting description for item id: "+item.getId();
|
|
|
|
throw new Exception(error);
|
|
|
|
}
|
|
|
|
}
|
2013-02-06 15:40:17 +01:00
|
|
|
}
|