package org.ngbw.web.actions;

import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.file.attribute.FileTime;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.validation.SkipValidation;

import org.ngbw.sdk.Workbench;
import org.ngbw.sdk.WorkbenchSession;
import org.ngbw.sdk.api.core.GenericDataRecordCollection;
import org.ngbw.sdk.common.util.CipresTaskThread;
import org.ngbw.sdk.common.util.StringUtils;
import org.ngbw.sdk.core.shared.IndexedDataRecord;
import org.ngbw.sdk.core.types.DataFormat;
import org.ngbw.sdk.core.types.DataType;
import org.ngbw.sdk.core.types.EntityType;
import org.ngbw.sdk.core.types.RecordFieldType;
import org.ngbw.sdk.core.types.RecordType;
import org.ngbw.sdk.database.DataParseStatus;
import org.ngbw.sdk.database.DataRecord;
import org.ngbw.sdk.database.Folder;
import org.ngbw.sdk.database.FolderItem;
import org.ngbw.sdk.database.SourceDocument;
import org.ngbw.sdk.database.User;
import org.ngbw.sdk.database.UserDataItem;
import org.ngbw.cipres.sdk.api.foldershare.policy.AppendCopyDuplicateNumberPolicy;
import org.ngbw.sdk.foldershare.task.FileUploadTask;
import static org.ngbw.web.actions.NgbwSupport.LIST;
import org.ngbw.web.model.Page;
import org.ngbw.web.model.Tab;
import org.ngbw.web.model.TabbedPanel;
import org.ngbw.web.model.impl.ConceptComparator;
import org.ngbw.web.model.impl.ListPage;
import org.ngbw.web.model.impl.RecordFieldTypeComparator;
import edu.sdsc.globusauth.controller.GlobusDataImportManager;
import java.io.File;
import org.apache.commons.io.FileUtils;
import org.ngbw.sdk.database.Statistics;
import org.ngbw.sdk.database.Task;
import org.ngbw.sdk.database.TaskOutputSourceDocument;
import org.ngbw.sdk.database.TaskRun;
import org.ngbw.sdk.database.TaskInputSourceDocument;

/**
 * Struts action class to process all user data-related requests in the NGBW web application.
 *
 * @author Jeremy Carver
 */
@SuppressWarnings("serial")
public class DataManager extends FolderManager
{
    //TODO: Implement this class with a proper DataController

    private static final Logger logger = Logger.getLogger(DataManager.class);

    // parameter attribute key constants
    public static final String PAGE = "page";
    public static final String SORT = "sort";

    // session attribute key constants
    public static final String CURRENT_DATA = "currentData";
    public static final String FOLDER_DATA = "folderData";
    public static final String SELECTED_DATA_ITEMS = "selectedDataItems";

    // result constants
    public static final String DOWNLOAD = "download";
    public static final String ARCHIVE_DATA = "archiveData";
    public static final String GLOBUS_TRANSFER = SessionManager.GLOBUS_TRANSFER;

    public static final String TRANSFER_DATA_ITEMS  = "transferDataItems";
    public static final String TRANSFER_TASK_OUTPUT = "transferTaskOutput";

    // data tab properties
    public static final String DATA_TAB_SORT_TYPE = "Data_Tab_Sort_Type";
    public static final String DATA_TAB_TYPE = "dataTabType";
    public static final String RECORD_TYPE = "recordType";
    public static final String DATA_FORMAT = "dataFormat";
    public static final String DATA_RECORDS = "dataRecords";
    public static final String UNKNOWN_TAB = "Unknown";
    public static final String ALL_DATA_TAB = "All Data";
    public static final String DATA_PAGE_SIZE = "dataPageSize";

    // data action constants
    public static final String MOVE             = "Move";
    public static final String COPY             = "Copy";
    public static final String DELETE_SELECTED  = "Delete Selected";

    // record type constants
    public static final String COMPOUND_STRUCTURE = "COMPOUND_STRUCTURE";
    public static final String APPLICATION_DATA = "APPLICATION_DATA_SERIALIZED_BINARY";
    public static final String DATA_SECTION = "Data";
    public static final String HOME = "home";
    // semantic tag constants
//    public static final String UNKNOWN = "UNKNOWN";

    // maximum size (in bytes) of data to be displayed
    public static long MAX_DATA_SIZE = setMaxDataDisplaySize(2097152L);

    // TODO: for debugging, setting this to a ridiculously low value instead of 2MB.
    // public static final int MAX_DATA_SIZE = 1000;	// 200 bytes
    // file download default constants
    public static final String DEFAULT_FILENAME = "output";
    public static final String DEFAULT_CONTENT_TYPE = "text/plain";

    // Sirius type constants
    public static final int DATA = -1;
    public static final int VIEW = 3;

    private static int TASK_SIZE_PER_FOLDER = 100;
    
    // cached current data item
    private UserDataItem currentData;

    List<Folder> folders = null;
    GlobusDataImportManager gdim = new GlobusDataImportManager();
    
    // data list form properties
    private List<RecordFieldType> fields;
    private Long[] selectedIds;  // IDs of data files.
    private Long targetFolder;
    private String dataAction;
	private int[] arr = new int[]{1, 2};
    // data display page properties
    protected GenericDataRecordCollection<IndexedDataRecord> dataRecords;
    protected SourceDocument sourceDocument;


    static
    {
        try
        {
            TASK_SIZE_PER_FOLDER = Integer.parseInt(wbProperties.getProperty("max.task.size.folder") == null? "100":wbProperties.getProperty("max.task.size.folder"));
        }
        catch ( Exception e )
        {
            TASK_SIZE_PER_FOLDER = 100;
        }
    }
	public int[] getArr() {
		return this.arr;
	}
	public void setArr(int[] a) {
		this.arr = a;
	}
    private static long setMaxDataDisplaySize ( long defaultValue )
    {
        final String property = "max.data.display.size";

        try
        {
            long value;

            value = Long.parseLong(wbProperties.getProperty(property));

            logger.debug(String.format("Set '%s' to %s (%d bytes).",
                                       property,
                                       StringUtils.getDataSizeForDisplay(value),
                                       value));
            return value;
        }
        catch ( Exception e )
        {
            logger.error(
                String.format("Error retrieving property '%s.' %s. Using default value [%d]",
                              property, e.toString(), defaultValue));

            return defaultValue;
        }
    }


    // ================================================================
    // Action methods
	// ================================================================

    @Override
    public String input ()
    {
        return super.input();
    }


    @Override
    public String execute () throws Exception
    {
        return super.execute();
    }


    @Override
    public String list () throws Exception
    {
        logger.trace("BEGIN: list()::String");

        String retVal = HOME;

        Folder folder = getRequestFolder(ID);

        if (folder == null)
        {
            folder = getCurrentFolder();
        }

        if (folder == null)
        {
            logger.error(reportUserError("You must select a folder to view its data."));
            retVal = HOME;
        }
        else
        {
            if (!isCurrentFolder(folder))
            {
                setCurrentFolder(folder);
                logger.debug(String.format("Set current folder to [%s]", folder.getLabel()));
            }

            TabbedPanel<UserDataItem> tabs = getFolderDataTabs();

            String tab = getRequestParameter(TAB);

            if (tab != null)
            {
                tabs.setCurrentTab(tab);
            }

            clearCurrentData();

            retVal = LIST;
        }

        logger.trace("END: list()::String");

        return retVal;
    }
    
    public String refresh() throws Exception
    {

        if (gdim != null)
        {
            String username = null;
            try
            {
                username = getWorkbenchSession().getUser().getUsername();
                logger.info("Username = " + username);
                gdim.setUsername(username);
                gdim.uploadGlobusData();
            }
            catch (Exception e)
            {
                logger.error("Get below exception while getting username");
                logger.error(e.toString());
            }

        }
     
        refreshFolderDataTabs();
     
        return list();
    }

	public String reload() {
		return SUCCESS;
	}

	public List<UserDataItem> getLoadingDataTab ()
    {
        try
        {
            logger.trace("BEGIN: getLoadingDataTab()::List<UserDataItem>");
            List<UserDataItem> dataItems = getCurrentDataTab();
			List<UserDataItem> loadingDataTab = new ArrayList<>();
			for (UserDataItem data : dataItems) {
				switch((int)data.getParseStatus()) {
					case 1:
					case 2:
						loadingDataTab.add(data);
						break;
				}
			}
            logger.trace("END: getLoadingDataTab()::List<UserDataItem>");
            return loadingDataTab;
        }
        catch ( Exception e )
        {
            logger.error(e.getMessage(), e);
            return null;
        }
    }
    @SkipValidation
    public String paginate ()
    {
//        logger.debug("BEGIN: paginate()::String");
        setPageNumber(0);
//        logger.debug("END: paginate()::String");
        return LIST;
    }


    @SkipValidation
    public String setPage ()
    {
        logger.debug("BEGIN: setPage()::String");

        String page = getRequestParameter(PAGE);

        if (page != null)
        {
            logger.debug(String.format("Setting page number to [%s] ...", page));
            setPageNumber(Integer.parseInt(page));
        }
        else
        {
            addActionError("You must select a page number to change pages.");
        }

        logger.debug("END: setPage()::String");

        return LIST;
    }


    @SkipValidation
    public String changeTabSorting ()
    {
        String oldSortType = getDataTabSortType();
        if (oldSortType == null || oldSortType.equals(RECORD_TYPE))
        {
            setDataTabSortType(DATA_FORMAT);
        }
        else
        {
            setDataTabSortType(RECORD_TYPE);
        }
        refreshFolderDataTabs();
        return LIST;
    }


    @SkipValidation
    @Override
    public String display ()
    {
        // get selected data ID from request param, if present
        String[] dataId = (String[]) getParameters().get(ID);

        if (dataId != null && dataId.length > 0)
        {
            setCurrentData(getSelectedData(Long.parseLong(dataId[0])));
            return DISPLAY;
        }
        else if (getCurrentData() != null)
        {
            return DISPLAY;
        }
        else
        {
            addActionError("You must select a data item to view its details.");
            return LIST;
        }
    }


    @SkipValidation
    public String download ()
    {
        return DOWNLOAD;
    }


    @SkipValidation
    @Override
    public String delete ()
    {
        // delete the current data item
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                logger.error(reportUserError("You must select a data item to delete it."));
            }
            else
            {
                String dataLabel = currentData.getLabel();
                if (deleteData(currentData))
                {
                    setCurrentData(null);
                    reportUserMessage("Data item \"" + dataLabel + "\" successfully deleted.");
                    refreshFolderDataTabs();
                }
                else
                {
                    logger.error(reportUserError("Data item \"" + dataLabel + "\" could not be deleted."));
                    return DISPLAY;
                }
            }
            return LIST;
        }
        catch ( Throwable error )
        {
            logger.error("Error deleting data item", error);
            return ERROR;
        }
    }


    @SkipValidation
    @Override
    public String cancel ()
    {
        logger.debug("BEGIN: cancel()::String");

        String retVal = LIST;

        String action = getDataAction();

        if (action == null)
        {
            addActionError("You must select an action to manipulate your data.");
        }
        else
        {
            logger.debug(String.format("DataAction=[%s]", action));

            Long[] selectedIds = getSelectedIds();

            if (selectedIds == null || selectedIds.length == 0)
            {
                logger.debug("No UserDataItem selected.");
                addActionError("You must select one or more data items to "
                                + action.toLowerCase() + " them.");
            }
            else
            {
                String[] button = (String[]) getParameters().get("method:cancel");

                if (button != null && button.length > 0)
                {
                    logger.debug(String.format("Button Pressed=[%s]", button[0]));
                }

                if (button != null && button.length > 0 && button[0].equals(DELETE_SELECTED))
                {
                    retVal = deleteSelected();
                }
                else
                {
                    Folder folder = getCurrentFolder();
                    Long targetFolder = getTargetFolder();

                    if (targetFolder == null)
                    {
                        addActionError("You must select a target folder to "
                                + action.toLowerCase() + " your data.");
                    }
                    else if (targetFolder.equals(folder.getFolderId()))
                    {
                        addActionError("You must select a new folder to "
                                + action.toLowerCase() + " your data into.");
                    }
                    else if (action.equalsIgnoreCase(MOVE))
                    {
                        int moved = moveSelectedDataItems();
                        String result = moved + " data item";
                        if (moved != 1)
                        {
                            result += "s were ";
                        }
                        else
                        {
                            result += " was ";
                        }
                        result += "successfully moved.";
                        reportUserMessage(result);
                        refreshFolderDataTabs();
                    }
                    else if (action.equalsIgnoreCase(COPY))
                    {
                        int copied = copySelectedDataItems();
                        String result = copied + " data item";
                        if (copied != 1)
                        {
                            result += "s were ";
                        }
                        else
                        {
                            result += " was ";
                        }
                        result += "successfully copied.";
                        reportUserMessage(result);
                        refreshFolderDataTabs();
                    }
                    else
                    {
                        addActionError("You have requested an unrecognized data action, "
                                + "please select from the list below.");
                    }
                }
            }
        }

        logger.debug("END: cancel()::String");

        return retVal;
    }


    @SkipValidation
    public String deleteSelected ()
    {
        logger.debug("BEGIN: deleteSelected()::String");

        Long[] selectedIds = getSelectedIds();

        if (selectedIds == null || selectedIds.length == 0)
        {
            addActionError("You must select one or more data items to delete them.");
        }
        else
        {
            int deleted = deleteSelectedDataItems();

            int remaining = selectedIds.length - deleted;

            if (deleted > 0)
            {
                String result = deleted + " data item";

                if (deleted != 1) {
                    result += "s were ";
                }
                else {
                    result += " was ";
                }

                result += "successfully deleted.";

                reportUserMessage(result);

                refreshFolderDataTabs();
            }

            if (remaining > 0)
            {
                String result = remaining + " data item";

                if (remaining != 1)
                {
                    result += "s";
                }

                result += " could not be deleted.";

                logger.error(reportUserError(result));
            }
        }

        setCurrentData(null);

        logger.debug("END: deleteSelected()::String");

        return LIST;
    }

    /* ================================================================
     * Data list form property accessor methods
	 *================================================================ */



    /**
     * Returns user selected IDs of data file(s).
     *
     * @return
     */
    public Long[] getSelectedIds ()
    {
        return selectedIds;
    }


    public void setSelectedIds ( Long[] selectedIds )
    {
        this.selectedIds = selectedIds;
    }


    public String getDataAction ()
    {
        return dataAction;
    }


    public void setDataAction ( String dataAction )
    {
        this.dataAction = dataAction;
    }


    public Long getTargetFolder ()
    {
        return targetFolder;
    }


    public void setTargetFolder ( Long targetFolder )
    {
        this.targetFolder = targetFolder;
    }


    /*
     * ================================================================
     * Data list page property
     * accessor methods
	 *================================================================
     */
    @SuppressWarnings("unchecked")
    public TabbedPanel<UserDataItem>
    getFolderDataTabs ()
    {
        logger.trace("BEGIN: getFolderDataTabs()::TabbedPanel<UserDataItem>");
        boolean needToRefresh = false;
        List<Folder> foldersNow = (List<Folder>) getSessionAttribute(FOLDERS);
        if (folders != null)
        {
            needToRefresh = (folders != foldersNow);
        }
        folders = foldersNow;
        
        TabbedPanel<UserDataItem> folderData =
                (TabbedPanel<UserDataItem>) getSessionAttribute(FOLDER_DATA);

        if (folderData == null || !folderData.isParentFolder(getCurrentFolder()) || needToRefresh)
        {
            logger.debug("TabbedPanel<UserDataItem> is null. Calling refreshFolderDataTabs()...");
            folderData = refreshFolderDataTabs();
        }

        logger.trace("END: getFolderDataTabs()::TabbedPanel<UserDataItem>");

        return folderData;
    }


    @SuppressWarnings("unchecked")
    public void setFolderDataTabs ( TabbedPanel<UserDataItem> folderData )
    {
        setSessionAttribute(FOLDER_DATA, folderData);
    }


    public boolean hasFolderData ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        return (folderData != null && folderData.getTabs().getTotalNumberOfElements() > 0);
    }


    public List<String> getTabLabels ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return null;
        }
        else
        {
            return folderData.getTabLabels();
        }
    }


    public String getFirstTabLabel ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return null;
        }
        else
        {
            return folderData.getFirstTabLabel();
        }
    }


    public String getCurrentTabLabel ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return null;
        }
        else
        {
            Tab<UserDataItem> currentTab = folderData.getCurrentTab();
            if (currentTab == null)
            {
                return null;
            }
            else
            {
                return currentTab.getLabel();
            }
        }
    }


    public boolean isCurrentTabUnknown ()
    {
        String currentTabLabel = getCurrentTabLabel();
        if (currentTabLabel == null)
        {
            return false;
        }
        boolean flag = currentTabLabel.equals(UNKNOWN_TAB);
        return flag;
    }


    public boolean isCurrentTabPhysical ()
    {
        try
        {
            String dataTabSortType = getDataTabSortType();

            if (!dataTabSortType.equals(RECORD_TYPE))
            {
                return true;
            }

            String currentTabLabel = getCurrentTabLabel();

            if (currentTabLabel == null)
            {
                return false;
            }

            return currentTabLabel.equals(ALL_DATA_TAB);
        }
        catch ( Exception e )
        {
            logger.error(e.getMessage(), e);
            return false;
        }
    }


    public int getCurrentTabSize ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return 0;
        }
        else
        {
            return folderData.getCurrentTabSize();
        }
    }

    //TODO: add sort functionality to user interface

    public List<UserDataItem> getCurrentDataTab ()
    {
        try
        {
            logger.trace("BEGIN: getCurrentDataTab()::List<UserDataItem>");

            TabbedPanel<UserDataItem> folderData = getFolderDataTabs();

            List<UserDataItem> dataItems = (null == folderData)?
                                           null : folderData.getCurrentTabContents();
            
            /*
            if (null != dataItems)
            {
                Collections.sort(dataItems, UserDataItem.SORT_BY_CREATED_TIME_DESC);
            }
            */

            logger.trace("END: getCurrentDataTab()::List<UserDataItem>");
            logger.trace("END: currentDataTab() Size of List::" + dataItems.size());
            return dataItems;
        }
        catch ( Exception e )
        {
            logger.error(e.getMessage(), e);
            return null;
        }
    }


    @SuppressWarnings("unchecked")
    public Enum getCurrentTabType ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return null;
        }
        else
        {
            Tab<UserDataItem> currentTab = folderData.getCurrentTab();
            if (currentTab == null)
            {
                return null;
            }
            else
            {
                return (Enum) currentTab.getProperty(DATA_TAB_TYPE);
            }
        }
    }


    @SuppressWarnings("unchecked")
    public Map<UserDataItem, GenericDataRecordCollection<IndexedDataRecord>>
    getCurrentTabDataRecordMap ()
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return null;
        }
        else
        {
            Tab<UserDataItem> currentTab = folderData.getCurrentTab();
            if (currentTab == null)
            {
                return null;
            }
            else
            {
                return (Map<UserDataItem, GenericDataRecordCollection<IndexedDataRecord>>) currentTab.getProperty(DATA_RECORDS);
            }
        }
    }


    public void
    setCurrentTabDataRecordMap (
            Map<UserDataItem,
            GenericDataRecordCollection<IndexedDataRecord>> dataRecordMap )
    {
        TabbedPanel<UserDataItem> folderData = getFolderDataTabs();
        if (folderData == null)
        {
            return;
        }
        else
        {
            Tab<UserDataItem> currentTab = folderData.getCurrentTab();
            if (currentTab == null)
            {
                return;
            }
            else if (dataRecordMap != null)
            {
                currentTab.setProperty(DATA_RECORDS, dataRecordMap);
            }
            else
            {
                currentTab.removeProperty(DATA_RECORDS);
            }
        }
    }


    @SuppressWarnings("unchecked")
    public List<RecordFieldType> getCurrentTabFields ()
    {
        List<RecordFieldType> emptyList = new ArrayList<RecordFieldType>();

        // get the fields list stored in the action
        if (fields != null)
        {
            return fields;
        }
        // if not not found, construct the proper fields list
        else
        {
            try
            {
                Workbench workbench = getWorkbench();
                RecordType recordType = (RecordType) getCurrentTabType();
                if (workbench == null)
                {
                    throw new NullPointerException("No workbench is present.");
                }
                else if (recordType == null)
                {
                    throw new NullPointerException("No record type has been registered with "
                            + "the current data tab.");
                }
                else
                {
                    Set<RecordFieldType> fieldSet = getWorkbench().getRecordFields(recordType);
                    if (fieldSet == null || fieldSet.size() < 1)
                    {
                        return emptyList;
                    }
                    else
                    {
                        fields = sortRecordFields(fieldSet);
                        return fields;
                    }
                }
            }
            catch ( RuntimeException error )
            {
                //TODO: this should be a proper checked exception
                logger.error("Error retrieving record field list for current data tab", error);
                return emptyList;
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving record field list for current data tab", error);
                return emptyList;
            }
        }
    }


    public SourceDocument getSourceDocument ( UserDataItem dataItem )
    {
        // first try the source document stored in the action
        if (sourceDocument != null && currentData != null
                && dataItem != null && currentData.getUserDataId() == dataItem.getUserDataId())
        {
            return sourceDocument;
        }
        // if not found, retrieve it from the workbench
        else
        {
            try
            {
                WorkbenchSession session = getWorkbenchSession();
                if (session == null)
                {
                    throw new NullPointerException("No session is present.");
                }
                else if (dataItem == null)
                {
                    throw new NullPointerException("No data item is currently selected.");
                }
                else
                {
                    sourceDocument = session.getSourceDocument(dataItem);
                    currentData = dataItem;
                    return sourceDocument;
                }
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving source document from selected data item");
                return null;
            }
        }
    }


    public boolean hasSourceDocument ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return false;
        }
        else
        {
            return (getSourceDocument(dataItem) != null);
        }
    }


    public GenericDataRecordCollection<IndexedDataRecord> getDataRecords ( UserDataItem dataItem )
    {
        Map<UserDataItem, GenericDataRecordCollection<IndexedDataRecord>> dataRecordMap
                = getCurrentTabDataRecordMap();
        if (dataRecordMap != null && dataItem != null)
        {
            // this loop is necessary because the argument data item instance
            // might transiently differ from the map key, even if they have the
            // same ID and therefore represent the same data item
            for (UserDataItem storedDataItem : dataRecordMap.keySet())
            {
                if (storedDataItem.getUserDataId() == dataItem.getUserDataId())
                {
                    return dataRecordMap.get(storedDataItem);
                }
            }
            return null;
        }
        else
        {
            return null;
        }
    }


    public List<IndexedDataRecord> getDataRecordList ( UserDataItem dataItem )
    {
        GenericDataRecordCollection<IndexedDataRecord> dataRecords = getDataRecords(dataItem);
        if (dataRecords == null)
        {
            return null;
        }
        else
        {
            return dataRecords.toList();
        }
    }


    public boolean hasDataRecords ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return false;
        }
        else
        {
            return (getDataRecords(dataItem) != null);
        }
    }


    public String getRecordField ( RecordFieldType recordFieldType )
    {
        if (recordFieldType == null)
        {
            return null;
        }
        else
        {
            return getConceptLabel("RecordField", recordFieldType.toString());
        }
    }


    public boolean isPrimaryId ( RecordFieldType recordFieldType )
    {
        if (recordFieldType == null)
        {
            return false;
        }
        else
        {
            return recordFieldType.equals(RecordFieldType.PRIMARY_ID);
        }
    }


    public String getDataRecordField ( DataRecord dataRecord, RecordFieldType recordFieldType )
    {
        if (dataRecord == null || recordFieldType == null)
        {
            return null;
        }
        else
        {
            return truncateText(dataRecord.getField(recordFieldType).getValueAsString());
        }
    }


    public boolean canDisplay ()
    {
        String currentTabLabel = getCurrentTabLabel();
        if (currentTabLabel == null)
        {
            return false;
        }
        else
        {
            return (currentTabLabel.contains("Structure")
                    || currentTabLabel.equals(getConceptLabel("RecordType", APPLICATION_DATA)));
        }
    }


    public int getSiriusType ()
    {
        String currentTabLabel = getCurrentTabLabel();
        if (currentTabLabel != null
                && currentTabLabel.equals(getConceptLabel("RecordType", APPLICATION_DATA)))
        {
            return VIEW;
        }
        else
        {
            return DATA;
        }
    }


    /*
     * "Unknown" and "All Data" tab property getters
     */
    public String getPrimaryId ( UserDataItem dataItem )
    {
        //TODO: this functionality should be in a data controller class
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            Workbench workbench = getWorkbench();
            if (workbench.canRead(dataItem.getType()) == false)
            {
                logger.debug(super.getUsernameString() + "Error extracting data records from data item " + dataItem.getUserDataId() + ": data item cannot be read.");
                return null;
            }
            else
            {
                try
                {
                    GenericDataRecordCollection<IndexedDataRecord> dataRecords
                            = workbench.extractDataRecords(dataItem);
                    if (dataRecords == null || dataRecords.size() < 1)
                    {
                        logger.debug(super.getUsernameString() + "Error extracting data records from data item "
                                + dataItem.getUserDataId() + ": data record collection parsed "
                                + "from data item is null or empty.");
                        return null;
                    }
                    else
                    {
                        //TODO: rather than hack into the first DataRecord, actually
                        // list out DataRecords in the task input selection interface,
                        // rather than just UserDataItems
                        return truncateText(
                                dataRecords.get(0).getField(RecordFieldType.PRIMARY_ID).getValueAsString());
                    }
                }
                catch ( Throwable error )
                {
                    logger.error("Error extracting data records from data item " + dataItem.getUserDataId(), error);
                    return null;
                }
            }
        }
    }


    public String getLabel ( UserDataItem dataItem )
    {
        //logger.debug("BEGIN: getLabel(UserDataItem)::String");
        String label = (dataItem == null)? null : truncateText(dataItem.getLabel());
        //logger.debug("label: " + label);
        //logger.debug("END: getLabel(UserDataItem)::String");
        return label;
    }

    public boolean isLabelTruncated(UserDataItem dataItem)
    {
       if (dataItem == null)
         return false;
       return !dataItem.getLabel().equals(getLabel(dataItem)); 
    }

    public String getLabelFull ( UserDataItem dataItem )
    {
        //logger.debug("BEGIN: getLabel(UserDataItem)::String");
        String label = (dataItem == null)? null : dataItem.getLabel();
        //logger.debug("label: " + label);
        //logger.debug("END: getLabel(UserDataItem)::String");
        return label;
    }

    // BIG_FILES

    public long getDataLength ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return 0;
        }
        try
        {
            return getSourceDocument(dataItem).getDataLength();
        }
        catch ( Exception e )
        {
            logger.error(e);
            return 0;
        }
    }


    public String getOwner ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            try
            {
                return dataItem.getUser().getUsername();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving username of user who owns data item "
                            + dataItem.getUserDataId());
                return null;
            }
        }
    }


    public String getGroup ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            try
            {
                return dataItem.getGroup().getGroupname();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving group name of group that owns data item "
                            + dataItem.getUserDataId());
                return null;
            }
        }
    }


    public String getCreationDate ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            try
            {
                return formatDate(dataItem.getCreationDate());
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving creation date of data item "
                            + dataItem.getUserDataId());
                return null;
            }
        }
    }


    public String getEntityType ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            return getConceptLabel("EntityType", dataItem.getEntityType().toString());
        }
    }


    public String getDataType ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            return getConceptLabel("DataType", dataItem.getDataType().toString());
        }
    }


    public String getDataFormat ( UserDataItem dataItem )
    {
        if (dataItem == null)
        {
            return null;
        }
        else
        {
            return getConceptLabel("DataFormat", dataItem.getDataFormat().toString());
        }
    }

    public UserDataItem getCurrentData ()
    {
//        // first try the data item stored in the action
//        if (currentData != null)
//        {
//            return currentData;
//        }
//        // if not found, retrieve it from the session
//        else
//        {
//            currentData = (UserDataItem) getSessionAttribute(CURRENT_DATA);
//            return currentData;
//        }

        logger.debug("BEGIN: getCurrentData()::UserDataItem");

        // if not found the data item stored in the action, retrieve it from the session
        if (currentData == null)
        {
            currentData = (UserDataItem) getSessionAttribute(CURRENT_DATA);
        }

        logger.debug("currentData is " + ((currentData == null)? "NULL." : "NOT NULL."));

        logger.debug("END: getCurrentData()::UserDataItem");

        return currentData;
    }


    public void setCurrentData ( UserDataItem dataItem )
    {
        logger.debug("BEGIN: setCurrentData(UserDataItem)::void");

        if (dataItem == null)
        {
            clearCurrentData();
        }
        else
        {
            setSessionAttribute(CURRENT_DATA, dataItem);
            currentData = dataItem;
        }

        logger.debug("END: setCurrentData(UserDataItem)::void");
    }


    public void clearCurrentData ()
    {
        clearSessionAttribute(CURRENT_DATA);
        currentData = null;
    }


    @Override
    public String getLabel ()
    {
        //logger.debug("BEGIN: getLabel()::String");

        String label = null;

        try
        {
            UserDataItem currData = getCurrentData();

            if (currData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }

            label = getLabel(currData);
        }
        catch ( NullPointerException error )
        {
            logger.error("Error retrieving label of current data item", error);
        }

        //logger.debug("END: getLabel()::String");
        return label;
    }


    public String getOwner ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getOwner(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving owner of current data item", error);
            return null;
        }
    }


    public String getGroup ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getGroup(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving group of current data item", error);
            return null;
        }
    }


    public String getCreationDate ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getCreationDate(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving creation date of current data item", error);
            return null;
        }
    }


    public String getEntityType ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getEntityType(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving entity type of current data item", error);
            return null;
        }
    }


    public String getDataType ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getDataType(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving data type of current data item", error);
            return null;
        }
    }


    public String getDataFormat ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return getDataFormat(currentData);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving data format of current data item", error);
            return null;
        }
    }


    public Set<String> getFields ()
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return currentData.metaData().keySet();
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving fields of current data item", error);
            return null;
        }
    }


    public boolean hasFields ()
    {
        Set<String> fields = getFields();
        return (fields != null && !fields.isEmpty());
    }


    public String getFieldLabel ( String field )
    {
        return getConceptLabel("RecordField", field);
    }


    public String getFieldLabel ( RecordFieldType field )
    {
        if (field == null)
        {
            return null;
        }
        else
        {
            return getFieldLabel(field.toString());
        }
    }


    public String getFieldValue ( String field )
    {
        try
        {
            UserDataItem currentData = getCurrentData();
            if (currentData == null)
            {
                throw new NullPointerException("No data item is currently selected.");
            }
            else
            {
                return truncateText(currentData.metaData().get(field));
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving value of field \"" + field
                        + "\" of current data item");
            return null;
        }
    }


    public String getFieldValue ( DataRecord dataRecord, RecordFieldType field )
    {
        if (dataRecord == null)
        {
            return null;
        }
        else
        {
            try
            {
                return dataRecord.getField(field).getValueAsString();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving value of field \"" + field
                            + "\" of current data record");
                return null;
            }
        }
    }


    public GenericDataRecordCollection<IndexedDataRecord> getDataRecords ()
    {
        // first try the data record collection stored in the action
        if (dataRecords != null)
        {
            return dataRecords;
        }
        // if not found, retrieve it from the workbench
        else
        {
            dataRecords = getDataRecords(getCurrentData());
            return dataRecords;
        }
    }


    public List<IndexedDataRecord> getDataRecordList ()
    {
        GenericDataRecordCollection<IndexedDataRecord> dataRecords = getDataRecords();
        if (dataRecords == null)
        {
            return null;
        }
        else
        {
            return dataRecords.toList();
        }
    }


    public boolean hasDataRecords ()
    {
        GenericDataRecordCollection<IndexedDataRecord> dataRecords = getDataRecords();
        if (dataRecords == null)
        {
            return false;
        }
        else
        {
            return (dataRecords.size() > 0);
        }
    }


    public List<RecordFieldType> getDataRecordFields ()
    {
        GenericDataRecordCollection<IndexedDataRecord> dataRecords = getDataRecords();
        if (dataRecords == null)
        {
            return null;
        }
        else
        {
            return sortRecordFields(dataRecords.getFields());
        }
    }


    public SourceDocument getSourceDocument ()
    {
        // first try the source document stored in the action
        if (sourceDocument != null)
        {
            return sourceDocument;
        }
        // if not found, retrieve it from the workbench
        else
        {
            sourceDocument = getSourceDocument(getCurrentData());
            return sourceDocument;
        }
    }


    public boolean hasSourceDocument ()
    {
        return (getSourceDocument() != null);
    }


    /**
     * This method is where dynamically dispatched source data rendering mechanisms should be
     * employed. The source data should be properly formatted HTML to be placed directly into the
     * data display page. The contents of this HTML can be whatever is appropriate for displaying
     * the particular source data in a web page.
     *
     * See SetTaskOutput.getFormattedOutput()
     * @return
     */
    public String getFormattedSourceData ()
    {
        SourceDocument sourceDocument = getSourceDocument();
        try
        {
            String theData = getSourceDataAsString(sourceDocument);
            if (theData != null)
            {
                //TODO: make sure the saved data item isn't meant to be rendered as HTML
                String output = StringEscapeUtils.escapeHtml(theData);
                return "<pre class=\"source\">" + output + "</pre>";
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving or formatting SourceDocument data", error);
        }
        return null;
    }


    /**
     * Gets the data as a string if the data item isn't too big. If it is, returns a canned message
     * instead.
     * @param sd
     * @return
     * @throws java.lang.Exception
     */
    public String getSourceDataAsString ( SourceDocument sd ) throws Exception
    {
        if (sd == null)
        {
            return null;
        }

        // TODO: make sure the file isn't binary.
        // TODO: display the beginning of the file, or create a viewer that streams it.
        if (sd.getDataLength() > MAX_DATA_SIZE)
        {
            return "Sorry, this file is too large to display.\n"
                    + "To view this file, please download it to your local machine.\n";
        }

        byte[] theData = sd.getData();

        return (theData == null)? null : new String(theData);
    }


    /*
     * ================================================================
     * Data download property
     * accessor methods
	 *================================================================
     */
    public String getFilename ()
    {
        logger.debug("BEGIN: getFilename()::String");

        String filename = getLabel();

        if (filename == null)
        {
            filename = DEFAULT_FILENAME;
            logger.debug("getLabel() returns null. Filename set to '" + filename + ".'");
        }
        else {
            logger.debug("filename set to '" + filename + ".'");
        }

        logger.debug("END: getFilename()::String");

        return filename;
    }


    public String getContentType ()
    {
        logger.debug("BEGIN: getContentType()::String");

        String filename = getFilename();

//        if (filename == null || filename.equals(DEFAULT_FILENAME))
//        {
//            return DEFAULT_CONTENT_TYPE;
//        }
//        else
//        {
//            String[] filenameTokens = filename.split("\\.");
//            String extension = filenameTokens[filenameTokens.length - 1];
//            String contentType = getConceptLabel("FileType", extension);
//
//            if (contentType.equals(extension))
//            {
//                return DEFAULT_CONTENT_TYPE;
//            }
//            else
//            {
//                return contentType;
//            }
//        }

        String contentType = DEFAULT_CONTENT_TYPE;

        if (filename != null && !filename.equals(DEFAULT_FILENAME))
        {
            String[] filenameTokens = filename.split("\\.");
            String extension = filenameTokens[filenameTokens.length - 1];
            String conceptLabel = getConceptLabel("FileType", extension);

            if (conceptLabel != null && !conceptLabel.equals(extension))
            {
                contentType = conceptLabel;
            }
        }

        logger.debug("contentType set to '" + contentType + ".'");

        logger.debug("END: getContentType()::String");

        return contentType;
    }


    public long getDataLength ()
    {
        SourceDocument document = getSourceDocument();
        try
        {
            if (document == null)
            {
                return 0;
            }

            return document.getDataLength();
        }
        catch ( IOException | SQLException error )
        {
            logger.error("Error retrieving size of data " + "from SourceDocument", error);
            return 0;
        }
    }


    public InputStream getInputStream ()
    {
        SourceDocument document = getSourceDocument();
        if (document == null)
        {
            return null;
        }
        else
        {
            try
            {
                return document.getDataAsStream();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving streamed data "
                            + "from SourceDocument");
                return null;
            }
        }
    }


    /*
     * ================================================================
     * Page methods
	 *================================================================
     */
    public Page<? extends FolderItem> getCurrentPage ()
    {
        return getFolderDataTabs().getCurrentTab().getContents();
    }


    public Integer getPageSize ()
    {
        return getCurrentPage().getPageSize();
    }


    public String getPageSizeString ()
    {
        return getPageSize().toString();
    }


    @SuppressWarnings("unchecked")
    public void setPageSize ( Integer pageSize )
    {
        logger.debug("BEGIN: setPageSize(Integer)::void");

        logger.debug(String.format("PageSize=[%d]", pageSize));

        try
        {
            getController().setUserPreference(DATA_PAGE_SIZE, pageSize.toString());

            TabbedPanel<UserDataItem> dataPanel = getFolderDataTabs();

            if (dataPanel != null && pageSize != null)
            {
                for (Tab<UserDataItem> dataTab : dataPanel.getTabs().getAllElements())
                {
                    List<UserDataItem> dataList = dataTab.getContents().getAllElements();
                    dataTab.setContents(new ListPage<UserDataItem>(dataList, pageSize));
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error saving user's selected data page size", error);
        }

        getCurrentPage().setPageSize(pageSize);

        logger.debug("END: setPageSize(Integer)::void");
    }


    public Integer getPageNumber ()
    {
        return getCurrentPage().getPageNumber();
    }


    @SuppressWarnings("unchecked")
    public void setPageNumber ( Integer pageNumber )
    {
        logger.debug("BEGIN: setPageNumber(Integer)::void");
        logger.debug(String.format("PageNumber=[%d]", pageNumber));
        getCurrentPage().setPageNumber(pageNumber);
        logger.debug("END: setPageNumber(Integer)::void");
    }


    public boolean isFirstPage ()
    {
        return getCurrentPage().isFirstPage();
    }


    public boolean isLastPage ()
    {
        return getCurrentPage().isLastPage();
    }


    public boolean hasPreviousPage ()
    {
        return getCurrentPage().hasPreviousPage();
    }


    public int getPreviousPageNumber ()
    {
        return getCurrentPage().getPreviousPageNumber();
    }


    public boolean hasNextPage ()
    {
        return getCurrentPage().hasNextPage();
    }


    public int getNextPageNumber ()
    {
        return getCurrentPage().getNextPageNumber();
    }


    public int getLastPageNumber ()
    {
        return getCurrentPage().getLastPageNumber();
    }


    public int getThisPageFirstElementNumber ()
    {
        return getCurrentPage().getThisPageFirstElementNumber();
    }


    public int getThisPageLastElementNumber ()
    {
        return getCurrentPage().getThisPageLastElementNumber();
    }


    public int getThisPageNumberOfElements ()
    {
        return getCurrentPage().getThisPageNumberOfElements();
    }


    /*
     * ================================================================
     * Internal property accessor
     * methods
	 *================================================================
     */
    protected UserDataItem getRequestData ( String parameter )
    {
        String dataId = getRequestParameter(parameter);
        if (dataId == null)
        {
            return null;
        }
        else
        {
            try
            {
                return getSelectedData(Long.parseLong(dataId));
            }
            catch ( NumberFormatException error )
            {
                return null;
            }
        }
    }


    /**
     * Retrieves UserDataItem from database.
     *
     * @param dataId ID of UserDataItem
     *
     * @return UserDataItem
     */
    protected UserDataItem getSelectedData ( Long dataId )
    {
        try
        {
            WorkbenchSession session = getWorkbenchSession();

            if (session == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else
            {
                return session.findUserDataItem(dataId);
            }
        }
        catch ( Throwable error )
        {
            logger.error(
                String.format(
                    "%s%s: %s",
                    getUsernameString(),
                    "Error retrieving selected UserDataItem",
                    error.getMessage()),
                error);

            return null;
        }
    }


    @SuppressWarnings("unchecked")
    protected List<SourceDocument> getSelectedDocuments ()
    {
        return (List<SourceDocument>) getSessionAttribute(SELECTED_DATA_ITEMS);
    }


    protected void setSelectedDocuments ()
    {
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            clearSessionAttribute(SELECTED_DATA_ITEMS);
        }
        else
        {
            List<SourceDocument> documents
                    = new Vector<SourceDocument>(selectedIds.length);
            for (int i = 0; i < selectedIds.length; i++)
            {
                UserDataItem dataItem = getSelectedData(selectedIds[i]);
                if (dataItem == null)
                {
                    throw new NullPointerException("Data item with ID "
                            + selectedIds[i] + " was not found.");
                }
                else
                {
                    documents.add(dataItem);
                }
            }
            if (documents.size() > 0)
            {
                setSessionAttribute(SELECTED_DATA_ITEMS, documents);
            }
            else
            {
                clearSessionAttribute(SELECTED_DATA_ITEMS);
            }
        }
    }


    protected String getDataTabSortType ()
    {
        return getFolderController().getFolderPreference(getCurrentFolder(), DATA_TAB_SORT_TYPE);
    }


    protected void setDataTabSortType ( String dataTabSortType )
    {
        if (dataTabSortType == null)
        {
            clearDataTabSortType();
        }
        else if (dataTabSortType.equals(RECORD_TYPE) || dataTabSortType.equals(DATA_FORMAT))
        {
            getFolderController()
                .setFolderPreference(
                    getCurrentFolder(),
                    DATA_TAB_SORT_TYPE,
                    dataTabSortType);
        }
        else
        {
            logger.debug(super.getUsernameString() + "Could not set data tab sorting preference, "
                    + "because the provided value was not a recognized sort type.");
        }
    }


    protected void clearDataTabSortType ()
    {
        getFolderController().clearFolderPreference(getCurrentFolder(), DATA_TAB_SORT_TYPE);
    }


    @SuppressWarnings("unchecked")
    protected TabbedPanel<UserDataItem> refreshFolderDataTabs ()
    {
        logger.trace("BEGIN: refreshFolderDataTabs()::TabbedPanel<UserDataItem>");

        try
        {
            Workbench workbench = getWorkbench();

            WorkbenchSession session = getWorkbenchSession();

            Folder folder = getCurrentFolder();

            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else if (session == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else if (folder == null)
            {
                throw new NullPointerException("No folder is currently selected.");
            }

            logger.debug("Current Folder: " + folder.getLabel());

            // retrieve user's preferred data tab sort type
            String dataTabSortType = getDataTabSortType();

            logger.debug("DataTabSortType: " + dataTabSortType);

            if (dataTabSortType == null)
            {
                dataTabSortType = RECORD_TYPE;
                setDataTabSortType(dataTabSortType);
            }

            // retrieve properly sorted data map based on user's preferred data tab sort type
            Map<? extends Enum, List<UserDataItem>> dataMap = null;

            if (dataTabSortType.equals(DATA_FORMAT))
            {
                dataMap = workbench.sortDataItemsByDataFormat(folder);
            }
            else
            {
                dataMap = workbench.sortDataItemsByRecordType(folder);
            }

            TabbedPanel<UserDataItem> tabPanelFolderData = null;

            if (dataMap != null && dataMap.size() > 0)
            {
                tabPanelFolderData = new TabbedPanel<>(folder);

                List<Tab<UserDataItem>> dataTabsList = new ArrayList<>(dataMap.size());

                String pageSize = getController().getUserPreference(DATA_PAGE_SIZE);
                logger.debug("PageSize: " + pageSize);

                // physical view tab = All Data Tab
                Page<UserDataItem> allDataPage = null;

                List<UserDataItem> allDataList = folder.findDataItems();
                Collections.sort(allDataList, UserDataItem.SORT_BY_CREATED_TIME_DESC);

                if (pageSize != null)
                {
                    try
                    {
                        allDataPage = new ListPage<>(
                                            allDataList,
                                            Integer.parseInt(pageSize));
                    }
                    catch ( NumberFormatException error )
                    {
                        allDataPage = new ListPage<>(allDataList);
                    }
                }
                else
                {
                    allDataPage = new ListPage<>(allDataList);
                }

                Tab<UserDataItem> allDataTab = new Tab<>(allDataPage, ALL_DATA_TAB);

                dataTabsList.add(allDataTab);

                tabPanelFolderData.setTabs(new ListPage<Tab<UserDataItem>>(dataTabsList));

                tabPanelFolderData.sortTabs();
            }

            setFolderDataTabs(tabPanelFolderData);

            logger.trace("END: refreshFolderDataTabs()::TabbedPanel<UserDataItem>");

            return tabPanelFolderData;
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving tabbed folder data", error);
            return null;
        }
    }


    private boolean deleteData ( UserDataItem dataItem )
    {
        try
        {
            WorkbenchSession session = getWorkbenchSession();

            if (session == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else if (dataItem == null)
            {
                throw new NullPointerException("Data item was not found.");
            }
            else
            {
                Long id = dataItem.getUserDataId();
                session.deleteUserDataItem(dataItem);
                dataItem = session.findUserDataItem(id);
                return (dataItem == null)? true : false;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error deleting data item", error);
            return false;
        }
    }


    protected int moveSelectedDataItems ()
    {
        // get IDs of selected data items to move
        int moved = 0;
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            return moved;
        }

        // get target folder to move to
        Folder folder = getFolderController().getFolder(getTargetFolder());
        if (folder == null)
        {
            addActionError("Error moving data item to folder with ID "
                    + getTargetFolder() + ": folder not found.");
        }

        // move selected data items to target folder
        else
        {
            for (int i = 0; i < selectedIds.length; i++)
            {
                UserDataItem dataItem = getSelectedData(selectedIds[i]);
                if (dataItem == null)
                {
                    addActionError("Error moving data item with ID "
                            + selectedIds[i] + ": item not found.");
                }
                else
                {
                    try
                    {
                        getWorkbenchSession().move(dataItem, folder);
                        moved++;
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error moving data item \"" + dataItem.getLabel()
                                    + "\" to folder \"" + folder.getLabel() + "\"");
                    }
                }
            }
        }
        return moved;
    }


    protected int copySelectedDataItems ()
    {
        // get IDs of selected data items to copy
        int copied = 0;
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            return copied;
        }

        // get target folder to copy to
        Folder folder = getFolderController().getFolder(getTargetFolder());
        if (folder == null)
        {
            addActionError("Error copying data item to folder with ID "
                    + getTargetFolder() + ": folder not found.");
        }

        // copy selected data items to target folder
        else
        {
            for (int i = 0; i < selectedIds.length; i++)
            {
                UserDataItem dataItem = getSelectedData(selectedIds[i]);
                if (dataItem == null)
                {
                    addActionError("Error copying data item with ID "
                            + selectedIds[i] + ": item not found.");
                }
                else
                {
                    try
                    {
                        getWorkbenchSession().copy(dataItem, folder);
                        copied++;
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error copying data item \"" + dataItem.getLabel()
                                    + "\" to folder \"" + folder.getLabel() + "\"");
                    }
                }
            }
        }
        return copied;
    }


    protected int deleteSelectedDataItems ()
    {
        int deleted = 0;

        Long[] selectedIds = getSelectedIds();

        if (selectedIds == null || selectedIds.length == 0)
        {
            return deleted;
        }
        else
        {
            User user = null;

            for (int i = 0; i < selectedIds.length; i++)
            {
                UserDataItem dataItem = getSelectedData(selectedIds[i]);

                if (dataItem == null)
                {
                    addActionError(
                        String.format(
                            "Error deleting data item with ID %d: item not found.",
                            selectedIds[i]));
                }
                else
                {
                    try
                    {
                        if (deleteData(dataItem))
                        {
                            user = dataItem.getUser();
                            deleted++;
                        }
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error deleting data item \""
                                    + dataItem.getLabel() + "\"");
                    }
                }
            }

            if (user != null)
            {
                clearActionErrors();
                refreshUserDataSize(user);
            }
        }
        return deleted;
    }


    @SuppressWarnings("unchecked")
    protected String[] sortConceptSet ( Set conceptSet )
    {
        if (conceptSet == null || conceptSet.size() < 1)
        {
            return null;
        }
        else
        {
            String[] concepts = new String[conceptSet.size()];
            int i = 0;
            for (Object concept : conceptSet)
            {
                concepts[i] = concept.toString();
                i++;
            }
            Arrays.sort(concepts, new ConceptComparator());
            return concepts;
        }
    }


    @SuppressWarnings("unchecked")
    protected Map<String, String> mapConceptSet ( Set conceptSet, String conceptType )
    {
        String[] sortedConceptSet = sortConceptSet(conceptSet);
        Map<String, String> conceptMap = new TreeMap<String, String>(new ConceptComparator());
        if (sortedConceptSet != null)
        {
            for (String concept : sortedConceptSet)
            {
                String text = getConceptLabel(conceptType, concept);
                if (text.trim().startsWith(conceptType) == false)
                {
                    conceptMap.put(concept, text);
                }
            }
        }
        return conceptMap;
    }


    @SuppressWarnings("unchecked")
    protected List<RecordFieldType> sortRecordFields ( Set<RecordFieldType> recordFieldSet )
    {
        if (recordFieldSet == null || recordFieldSet.size() < 1)
        {
            return null;
        }
        else
        {
            RecordFieldType[] recordFields = new RecordFieldType[recordFieldSet.size()];
            int i = 0;
            for (RecordFieldType recordField : recordFieldSet)
            {
                recordFields[i] = recordField;
                i++;
            }
            Arrays.sort(recordFields, new RecordFieldTypeComparator());
            return Arrays.asList(recordFields);
        }
    }


    protected Set<EntityType> getEntityTypeSet ()
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else
            {
                Set<EntityType> entityTypes
                        = new HashSet<EntityType>(workbench.getEntityTypes());
                entityTypes.add(EntityType.UNKNOWN);
                return entityTypes;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered entity types", error);
            return null;
        }
    }


    protected Set<EntityType> getSearchableEntityTypeSet ()
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else
            {
                Set<EntityType> entityTypes
                        = new HashSet<EntityType>(workbench.getSearchableEntityTypes());
                entityTypes.add(EntityType.UNKNOWN);
                return entityTypes;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered entity types", error);
            return null;
        }
    }


    protected Set<DataType> getUnknownDataTypeSet ()
    {
        Set<DataType> unknown = new HashSet<DataType>(1);
        unknown.add(DataType.UNKNOWN);
        return unknown;
    }


    protected Set<DataType> getDataTypeSet ( EntityType entityType )
    {
        try
        {
            Workbench workbench = getWorkbench();

            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else if (entityType == null || entityType.toString() == null)
            {
                throw new NullPointerException("Selected entity type is not present.");
            }
            else
            {
                Set<RecordType> recordTypes = workbench.getRecordTypes(entityType);
                Set<DataType> dataTypes = new HashSet<DataType>(recordTypes.size());

                for (RecordType recordType : recordTypes)
                {
                    dataTypes.add(workbench.getDataType(recordType));
                }

                dataTypes.add(DataType.UNKNOWN);
                return dataTypes;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered data types "
                        + "for specified entity type");
            return null;
        }
    }


    protected Set<DataType> getSearchableDataTypeSet ( EntityType entityType )
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else if (entityType == null || entityType.toString() == null)
            {
                throw new NullPointerException("Selected entity type is not present.");
            }
            else
            {
                Set<RecordType> recordTypes = workbench.getSearchableRecordTypes();
                Set<DataType> dataTypes = new HashSet<DataType>();
                for (RecordType recordType : recordTypes)
                {
                    if (workbench.getEntityType(recordType).equals(entityType))
                    {
                        dataTypes.add(workbench.getDataType(recordType));
                    }
                }
                dataTypes.add(DataType.UNKNOWN);
                return dataTypes;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered data types "
                        + "for specified entity type");
            return null;
        }
    }


    protected RecordType getRecordType ( EntityType entityType, DataType dataType )
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else
            {
                Set<RecordType> recordTypes = workbench.getRecordTypes(entityType);
                for (RecordType recordType : recordTypes)
                {
                    if (workbench.getDataType(recordType).equals(dataType))
                    {
                        return recordType;
                    }
                }
                return null;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error converting entity type and data type to record type", error);
            return null;
        }
    }


    protected Set<DataFormat> getUnknownDataFormatSet ()
    {
        Set<DataFormat> unknown = new HashSet<DataFormat>(1);
        unknown.add(DataFormat.UNKNOWN);
        return unknown;
    }


    protected Set<DataFormat> getDataFormatSet ()
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else
            {
                Set<DataFormat> dataFormats
                        = new HashSet<DataFormat>(workbench.getRegisteredDataFormats());
                dataFormats.add(DataFormat.UNKNOWN);
                return dataFormats;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered data formats", error);
            return null;
        }
    }


    protected Set<DataFormat> getDataFormatSet ( RecordType recordType )
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else if (recordType == null || recordType.toString() == null)
            {
                throw new NullPointerException("Selected record type is not present.");
            }
            else
            {
                Set<DataFormat> dataFormats
                        = new HashSet<DataFormat>(workbench.getRegisteredDataFormats(recordType));
                dataFormats.add(DataFormat.UNKNOWN);
                return dataFormats;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered data formats "
                        + "for specified record type");
            return null;
        }
    }


    protected Set<DataFormat> getDataFormatSet ( EntityType entityType, DataType dataType )
    {
        try
        {
            Workbench workbench = getWorkbench();
            if (workbench == null)
            {
                throw new NullPointerException("No workbench is present.");
            }
            else if (entityType == null || entityType.toString() == null)
            {
                throw new NullPointerException("Selected entity type is not present.");
            }
            else if (dataType == null || dataType.toString() == null)
            {
                throw new NullPointerException("Selected data type is not present.");
            }
            else
            {
                RecordType recordType = getRecordType(entityType, dataType);
                if (recordType == null)
                {
                    return null;
                }
                else
                {
                    return getDataFormatSet(recordType);
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving set of registered data formats "
                        + "for specified entity type and data type");
            return null;
        }
    }


    public String getDataLengthForDisplay ( UserDataItem dataItem )
    {
        if (dataItem != null)
        {
            try {
                return StringUtils.getDataSizeForDisplay(getSourceDocument(dataItem).getDataLength());
            }
            catch ( Throwable t ) {
                logger.error(t.getMessage(), t);
            }
        }

        return "";
    }


    public String
    getParseStatusName ( UserDataItem dataItem ) throws IOException,
                                                        SQLException
    {
        return (dataItem != null)?
                (new UserDataItem(dataItem.getUserDataId())).getParseStatusName() :
                DataParseStatus.UNKNOWN().getName();
    }


    public boolean isAvailable ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isAvailable();
    }


    public boolean isParseQueued ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isParseQueued();
    }


    public boolean isParseProcessing ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isParseProcessing();
    }


    public boolean isParseSucceeded ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isParseSucceeded();
    }


    public boolean isParseFailed ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isParseFailed();
    }


    public boolean isParseUnknown ( UserDataItem udi ) throws IOException, SQLException
    {
        return (null == udi)? false : (new UserDataItem(udi.getUserDataId())).isParseUnknown();
    }


    public String getBlankLabel ( UserDataItem dataItem )
    {
        return "";
    }


    /**
     * When data files/documents are transferred to CIPRES Share site,
     * it is important that the directory structures should be maintained
     * (except the username) to avoid confusing.  This method reads the
     * structures of the directory and returns them in a List.
     *
     * <pre>
     * The directory structures of CIPRES data files/documents are in this form:
     *
     *   {@code /username/user-defined-folder-name/Data/clustal_test1.txt}
     *   ...
     *
     * where {@code user-defined-folder-name} can have multiple sub-directories.
     *
     * i.e.
     *   {@code /johndoe/beast/Data/clustal_test1.txt}
     *   {@code /johndoe/beast/aminoacid/Data/clustal_test2.txt}
     *   ...
     *
     * Invoking this method to transfer
     * {@code /johndoe/beast/Data/clustal_test1.txt}:
     *
     * {@code getUserDataItemDirectories(Task)} returns
     * {@code List ["beast", "Data"]}
     *
     * Invoking this method to transfer
     * {@code /johndoe/beast/aminoacid/Data/clustal_test2.txt}
     *
     * {@code getUserDataItemDirectories(Task)} returns
     * {@code List ["beast", "aminoacid", "Data"]}
     * </pre>
     *
     * <strong>
     * NOTE: The {@code username} will be removed.
     * </strong>
     *
     * @param task  the UserDataItem
     *
     * @return      directory structures
     *
     * @throws Throwable
     */
    private List<String>
    getUserDataItemDirectories ( UserDataItem dataItem ) throws Throwable
    {
        if (dataItem != null)
        {
            return dataItem.getDirectoryList(
                                getAuthenticatedUser(),
                                "Data");
        }

        return null;
    }


    /**
     * Transfers selected data files to CIPRES Share (SeedMe2) site.
     *
     * <p>
     * Directory structures will be maintained the same on CIPRES Share.
     *
     * @return
     *
     * @throws Throwable
     */
    public String
    transferSelectedData () throws Throwable
    {
        logger.debug("BEGIN: transferSelectedData()::String");

        List<SourceDocument> dataItems = null;

        // Get all selected files.
        Long[] selectedIds = getSelectedIds();

        if (selectedIds == null || selectedIds.length == 0)
        {
            logger.debug(super.reportUserError("Please select one or more data items to transfer."));
        }
        else
        {
            // Retrieve UserDataItems from database.
            dataItems = new ArrayList<>();

            for (Long id : selectedIds)
            {
                UserDataItem dataItem = new UserDataItem(id);

//                logger.debug("==================================================");
//                DataInspector.inspect(dataItem);
//                logger.debug("==================================================");

                dataItems.add(dataItem);
            }

            // If not found, return an error message.
            if (dataItems == null || dataItems.isEmpty())
            {
                logger.debug(super.reportUserError("Unable to retrieve documents."));
            }
            else
            {
                // Create a background task and pass the info to it to start the
                // uploading process.
                FileUploadTask fileUploadTask =
                                new FileUploadTask(
                                        getAuthenticatedUser(),
                                        getUserDataItemDirectories((UserDataItem) dataItems.get(0)),
                                        dataItems,
                                        new AppendCopyDuplicateNumberPolicy());

                CipresTaskThread thread = new CipresTaskThread(fileUploadTask);

                thread.start();

                super.reportUserMessage(NgbwSupport.CIPRES_SHARE_FILES_TRANS_MSG);
            }
        }

        setSelectedIds(null);

        refreshFolderDataTabs();

        setCurrentData(null);

        logger.debug("END: transferSelectedData()::String");

        return LIST;
    }
    
    public String transferSelectedDataToGlobusRoot () throws Throwable
    {
        logger.debug("BEGIN: transferSelectedDataToGlobusRoot()::String");

        List<SourceDocument> dataItems = null;

        String globusRoot = Workbench.getInstance().getProperties().getProperty( "database.globusRoot" );
        String userRootDir = globusRoot + "/" + super.getUsernameString().trim() + "/outbound";        
        String ownerRootDir = globusRoot + "/" + super.getUsernameString().trim();
        // Get all selected files.
        Long[] selectedIds = getSelectedIds();

        if (selectedIds == null || selectedIds.length == 0)
        {
            logger.debug(super.reportUserError("Please select one or more data items to transfer."));
            return LIST;
        }
        else
        {
            // Retrieve UserDataItems from database.
            dataItems = new ArrayList<>();

            for (Long id : selectedIds)
            {
                UserDataItem dataItem = new UserDataItem(id);

//                logger.debug("==================================================");
//                DataInspector.inspect(dataItem);
//                logger.debug("==================================================");

                dataItems.add(dataItem);
            }

            // If not found, return an error message.
            if (dataItems == null || dataItems.isEmpty())
            {
                logger.debug(super.reportUserError("Unable to retrieve documents."));
            }
            else
            {
                Folder folder = getCurrentFolder();
                if (folder != null)
                    userRootDir += "/" + folder.getLabel() + "/" + DATA_SECTION;
                for (SourceDocument srcDoc : dataItems)
                {
                    String filename = null; 
                    File outputFile = null; 
                    InputStream inputStream = null; 

                    try 
                    {
                        filename = (srcDoc instanceof UserDataItem)? 
                                   ((UserDataItem) srcDoc).getLabel() : srcDoc.getName();


                        outputFile = new File(userRootDir, filename);


                        logger.debug(String.format("Copying file [%s] to [%s] ...", filename, outputFile.getAbsolutePath()));
                        inputStream = srcDoc.getDataAsStream(); 

                        FileUtils.copyInputStreamToFile(inputStream, outputFile);
                        inputStream.close();
                        inputStream = null; 

                    }
                    catch (Exception e)
                    {
                        logger.error("Exception caught while transfering file(s) to Globus root");
                        logger.error(e);                

                    }
                    finally
                    {
                        try
                        {
                            if (inputStream != null)
                            inputStream.close();
                        }
                        catch (Exception innerEx)
                        {
                            logger.error("Exception caught while closing input stream");
                            logger.error(innerEx);
                        }
                    }
                }            
            }        
        }

        setSelectedIds(null);

        refreshFolderDataTabs();

        setCurrentData(null);

        String user_dir_owner_group = Workbench.getInstance().getProperties().getProperty( "database.userDirOwnerGroup");
        String cmd = "chgrp -R " + user_dir_owner_group + " " + ownerRootDir;
        Process process = Runtime.getRuntime().exec(cmd);
        process.waitFor();
        if (process.exitValue() != 0)
            logger.error("Cannot change owner group of  directory: " + ownerRootDir + " to " + user_dir_owner_group);
                            
        logger.debug("END: transferSelectedDataToGlobusRoot()::String");

        return GLOBUS_TRANSFER;        
    }

    public String transferAllDataToGlobusRoot () throws Throwable
    {
        logger.debug("BEGIN: transferAllDataToGlobusRoot()::String");

        String globusRoot = Workbench.getInstance().getProperties().getProperty( "database.globusRoot" );
        String userRootDir = globusRoot + "/" + super.getUsernameString().trim() + "/outbound";        
        String ownerRootDir = globusRoot + "/" + super.getUsernameString().trim();
        // Get all selected files.
        List<UserDataItem> dataItems = getCurrentDataTab();

        Folder folder = null;
        if (dataItems == null || dataItems.isEmpty())
        {
            logger.debug(super.reportUserError("Unable to retrieve documents."));
        }
        else
        {
            folder = getCurrentFolder();
            if (folder != null)
            {
                List<Task> taskList = folder.findTasks();
                if (taskList !=  null && taskList.size() > TASK_SIZE_PER_FOLDER)
                {
                     reportUserError("Sorry, your current folder (" + folder.getLabel() + ") has more than " + TASK_SIZE_PER_FOLDER + " tasks. Please delete some of them." );
                     return HOME; 
                }
                userRootDir += "/" + folder.getLabel() + "/" + DATA_SECTION;
            }
            for (SourceDocument srcDoc : dataItems)
            {
                String filename = null; 
                File outputFile = null; 
                InputStream inputStream = null; 

                try 
                {
                    filename = (srcDoc instanceof UserDataItem)? 
                                   ((UserDataItem) srcDoc).getLabel() : srcDoc.getName();


                    outputFile = new File(userRootDir, filename);


                    logger.debug(String.format("Copying file [%s] to [%s] ...", filename, outputFile.getAbsolutePath()));
                    inputStream = srcDoc.getDataAsStream(); 

                    FileUtils.copyInputStreamToFile(inputStream, outputFile);
                    inputStream.close();
                    inputStream = null; 

                }
                catch (Exception e)
                {
                    logger.error("Exception caught while transfering file(s) to Globus root");
                    logger.error(e);                

                }
                finally
                {
                    try
                    {
                        if (inputStream != null)
                        inputStream.close();
                    }
                    catch (Exception innerEx)
                    {
                        logger.error("Exception caught while closing input stream");
                        logger.error(innerEx);
                    }
                }
            }            
        }

        //refreshFolderDataTabs();

        String user_dir_owner_group = Workbench.getInstance().getProperties().getProperty( "database.userDirOwnerGroup");
        String cmd = "chgrp -R " + user_dir_owner_group + " " + ownerRootDir;
        Process process = Runtime.getRuntime().exec(cmd);
        process.waitFor();
        if (process.exitValue() != 0)
            logger.error("Cannot change owner group of  directory: " + ownerRootDir + " to " + user_dir_owner_group);
                            

        if (folder != null)
        {
            transferAllOutputToGlobusRoot(folder);

            //String result = "Your folder " + folder.getLabel()  + " has been copied to your Globus outbound area. Please go to Globus->Transfer to download your data/tasks.";
            //reportUserMessage(result);
        }
        logger.debug("END: transferAllDataToGlobusRoot()::String");
        return GLOBUS_TRANSFER;        
    }

    public String transferAllOutputToGlobusRoot (Folder folder)
    {
        logger.debug("BEGIN: transferSelectedOutputToGlobusRoot()::void");
        String user_dir_owner_group = Workbench.getInstance().getProperties().getProperty( "database.userDirOwnerGroup");
        /*
        setSelectedDataItems();
        
        List<SourceDocument> sourceDocuments = getSelectedDocuments();
        
        if (sourceDocuments ==  null || sourceDocuments.size() <= 0)
        {
            addActionError("You must select at least one file to start the transfer.");
            return displayOutput();
        }
        */ 
        String globusRoot = Workbench.getInstance().getProperties().getProperty( "database.globusRoot" );
        String userRootDirBase = globusRoot + "/" + super.getUsernameString().trim() + "/outbound";
        String ownerRootDir = globusRoot + "/" + super.getUsernameString().trim();
        
        try
        {
            Date startDate = null;
            logger.debug("transferAllOutputToGlobusRoot()::String folder " + (folder == null? "is null":"not null"));
            if (folder != null) 
            {   
                 List<Task> taskList = folder.findTasks();
                 logger.debug("transferAllOutputToGlobusRoot()::String taskList has size = " + taskList.size());
                 if (taskList != null && !taskList.isEmpty())
                 {
                      for (Task task : taskList)
                      {
                          Set<TaskRun> runs = task.runs();
                          logger.debug("transferAllOutputToGlobusRoot()::String task: " + task.getLabel() + " has " + runs.size() + " run(s) ");
                          if (runs != null && !runs.isEmpty())
                          {
                               for (TaskRun trun : runs)
                               {
                                    Integer run = trun.getRunNumber();
            
                                    Map<String, List<TaskOutputSourceDocument>> output = trun.output();
                                    Map<String, List<TaskInputSourceDocument>> input = trun.input();
                                    List<SourceDocument> sourceDocuments = new ArrayList<SourceDocument>();
                                    /*
                                    for (List<TaskInputSourceDocument> inList : input.values())
                                        for (TaskInputSourceDocument inDoc : inList)
                                            sourceDocuments.add(inDoc);
                                    */
                                    for (List<TaskOutputSourceDocument> outList : output.values())
                                        for (TaskOutputSourceDocument outDoc : outList)
                                            sourceDocuments.add(outDoc);
                     
                                    Date terminatedDate = null;
                                    try
                                    {
                                        Statistics s = Statistics.find(task.getJobHandle(), run.intValue());
                                        terminatedDate = s.getDateTerminated();
                                        startDate = s.getDateEntered();
                                    }
                                    catch (Exception ex)
                                    {
                                        logger.error(ex);
                                    }
                                    if (folder != null && task != null && run != null)
                                    {
                                        String userRootDir = userRootDirBase + "/" + folder.getLabel() + "/" + task.getLabel() + (run.intValue() == 1? "" : "_run" + run);
                                        for (SourceDocument srcDoc : sourceDocuments)
                                        {
                                            String filename = null; 
                                            File outputFile = null; 
                                            InputStream inputStream = null; 
        
                                            try 
                                            {
                                                filename = (srcDoc instanceof UserDataItem)? 
                                                ((UserDataItem) srcDoc).getLabel() : srcDoc.getName();
                                                if (srcDoc instanceof UserDataItem) 
                                                    logger.debug(String.format("File [%s] is UserDataItem  ...", ((UserDataItem) srcDoc).getLabel()));

                                                outputFile = new File(userRootDir, filename);
                        
                                                logger.debug(String.format("Copying file [%s] to [%s] ...", filename, outputFile.getAbsolutePath()));
                                                inputStream = srcDoc.getDataAsStream(); 
                        
                                                FileUtils.copyInputStreamToFile(inputStream, outputFile);
                                                inputStream.close();
                                                inputStream = null; 
                                                if (terminatedDate != null)
                                                    outputFile.setLastModified(terminatedDate.getTime());
                                            }
                                            catch (Exception e)
                                            {
                                                 logger.error("Exception caught while transfering file(s) to Globus root");
                                                 logger.error(e);                
                                            }
                                            finally
                                            {
                                                 try
                                                 {
                                                     if (inputStream != null)
                                                        inputStream.close();
                                                 }
                                                 catch (Exception innerEx)
                                                 {
                                                     logger.error("Exception caught while closing input stream");
                                                     logger.error(innerEx);
                                                 }
                                            }
        		                 }
                                         if (terminatedDate != null)
                                         {
                                             Path directoryPath = Paths.get(userRootDir);
                                             Files.setLastModifiedTime(directoryPath, FileTime.fromMillis(terminatedDate.getTime())); 
                                         }
                                   }
                              }
                          }
                      }
                 }
            }
           
            if (startDate != null)
            {
                File jobDir = new File(userRootDirBase);
                jobDir.setLastModified(startDate.getTime());
            } 
            
            String cmd = "chgrp -R " + user_dir_owner_group + " " + ownerRootDir;
            Process process = Runtime.getRuntime().exec(cmd);
            process.waitFor();
            if (process.exitValue() != 0)
                logger.error("Cannot change owner group of  directory: " + ownerRootDir + " to " + user_dir_owner_group);
        }
        catch (Exception e)
        {
            logger.error(e.toString());
            logger.error("Cannot change owner group of  directory: " + ownerRootDir + " to " + user_dir_owner_group);
        }
        logger.debug("END: transferSelectedOutputToGlobusRoot()::void");
        //return GLOBUS_TRANSFER;
        return HOME;
    }
}