package org.ngbw.web.actions;

import com.opensymphony.xwork2.ActionContext;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.Future;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

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

import org.ngbw.sdk.Workbench;
import org.ngbw.sdk.WorkbenchSession;
import org.ngbw.sdk.api.tool.ToolResource;
import org.ngbw.sdk.common.util.GsiSSHProcessRunner;
import org.ngbw.sdk.common.util.SSHExecProcessRunner;
import org.ngbw.sdk.database.ConnectionManager;
import org.ngbw.sdk.database.Folder;
import org.ngbw.sdk.database.Statistics;
import org.ngbw.sdk.database.Task;
import org.ngbw.sdk.database.TaskInputSourceDocument;
import org.ngbw.sdk.database.TaskOutputSourceDocument;
import org.ngbw.sdk.database.User;
import org.ngbw.sdk.database.UserDataItem;
import org.ngbw.sdk.database.util.TaskSortableField;
import org.ngbw.web.model.Page;
import org.ngbw.web.model.Tab;
import org.ngbw.web.model.TabbedPanel;
import org.ngbw.web.model.impl.ListPage;


/**
 * Struts action class to manage user tasks in the NGBW web application.
 *
 * @author mzhuang
 */
@SuppressWarnings("serial")
public class AdminTaskManager extends ManageTasks
{
    private static final Log logger = LogFactory.getLog(AdminTaskManager.class.getName());

    // session attribute key constants
    public static final String ADMIN_FOLDER_TASKS = "adminFolderTasks";

    private static final String NOT_AVAILABLE = "Not Available";

    public static final String CRJ = "crj";
    public static final String ACCOUNTACTIVATION = "accountActivation";
    public static final String ACCOUNTACTIVATED = "accountActivated";
    public static final String MULTIPLEACCOUNTS = "multipleAccounts";

    private static Folder invisibleFolder = null;
    private static final String LOGIN = "login";
    private static final String COMET = "comet";
    private static final String TSCC = "TSCC";
    private static final String EXPANSE = "expanse";
    private static final String COMET_RUNNING_JOBS_DETAILS = ".cometRunningJobsDetails";
    private static final String COMET_INQUEUE_JOBS_DETAILS = ".cometInQueueJobsDetails";
    private static final String EXPANSE_RUNNING_JOBS_DETAILS = ".expanseRunningJobsDetails";
    private static final String EXPANSE_INQUEUE_JOBS_DETAILS = ".expanseInQueueJobsDetails";    
    private static final String AWS_RUNNING_JOBS_DETAILS = ".awsRunningJobsDetails";
    private static final String AWS_INQUEUE_JOBS_DETAILS = ".awsInQueueJobsDetails";
    private static final String TSCC_RUNNING_JOBS_DETAILS = ".tsccRunningJobsDetails";
    private static final String TSCC_INQUEUE_JOBS_DETAILS = ".tsccInQueueJobsDetails";
    /*
     * private static final String NONAWS_JOB_COUNT_CMD = "qstat |grep cipres |grep -c -v aws";
     * private static final String NONAWS_JOB_RUNNING_COUNT_CMD = "qstat |grep cipres |grep -v aws |grep -c ' R '";
     * private static final String NONAWS_JOB_RUNNING_CMD = "qstat |grep 'cipres\\|Username' |grep -v aws |grep ' R
     * \\|Username' > ./" + COMET_RUNNING_JOBS_DETAILS;
     * private static final String NONAWS_JOB_INQUEUE_CMD = "qstat |grep 'cipres\\|Username' |grep -v 'aws\\| R ' > ./"
     * + COMET_INQUEUE_JOBS_DETAILS;
     * private static final String AWS_JOB_COUNT_CMD = "qstat |grep cipres |grep -c aws";
     * private static final String AWS_JOB_RUNNING_COUNT_CMD = "qstat |grep cipres |grep aws |grep -c ' R '";
     * private static final String AWS_JOB_RUNNING_CMD = "qstat |grep 'cipres\\|Username' |grep 'aws\\|Username' |grep '
     * R \\|Username' > ./" + AWS_RUNNING_JOBS_DETAILS;
     * private static final String AWS_JOB_INQUEUE_CMD = "qstat |grep 'cipres\\|Username' |grep 'aws\\|Username' |grep
     * -v ' R ' > ./" + AWS_INQUEUE_JOBS_DETAILS;
     * private static final String TSCC_JOB_COUNT_CMD = "qstat |grep -c cipres";
     * private static final String TSCC_JOB_RUNNING_COUNT_CMD = "qstat |grep cipres |grep -c ' R '";
     * private static final String TSCC_JOB_RUNNING_CMD = "qstat |grep 'cipres\\|User' |grep ' R \\|User' > ./" +
     * TSCC_RUNNING_JOBS_DETAILS;
     * private static final String TSCC_JOB_INQUEUE_CMD = "qstat |grep 'cipres\\|User' |grep -v ' R ' > ./" +
     * TSCC_INQUEUE_JOBS_DETAILS;
     */
    private static final String ALL_JOB_RUNNING_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = R'";
    private static final String ALL_JOB_INQUEUE_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = C\\|job_state = E\\|job_state = H\\|job_state = Q\\|job_state = T\\|job_state = W\\|job_state = S\\|job_state = U'";

    private static final String EXPANSE_JOB_COUNT_CMD = "module load slurm;squeue -u cipres |grep -c cipres";
    private static final String EXPANSE_JOB_RUNNING_COUNT_CMD = "module load slurm;squeue -u cipres |grep cipres |grep -c ' R '";
    private static final String EXPANSE_JOB_RUNNING_CMD = "module load slurm;squeue -u cipres -o \"%.9i %.10P %.66j %.8u %.2t %.10M\" |grep ' R \\|PARTITION' > ./" + EXPANSE_RUNNING_JOBS_DETAILS;
    private static final String EXPANSE_JOB_INQUEUE_CMD = "module load slurm;squeue -u cipres -o \"%.9i %.10P %.66j %.8u %.2t %.10M\" |grep -v ' R ' > ./" + EXPANSE_INQUEUE_JOBS_DETAILS;
    //private static final String EXPANSE_JOB_INQUEUE_CMD = "module load slurm;squeue -u cipres -o \"%.9i %.10P %.66j %.8u %.2t %.10M\" |grep ' Q \\| PD \\| C \\| E \\| H \\| T \\| W \\| S \\| U \\|PARTITION' > ./" + EXPANSE_INQUEUE_JOBS_DETAILS;
    
    private static final String NONAWS_JOB_COUNT_CMD = "qstat -u cipres |grep cipres |grep -c -v aws";
    private static final String NONAWS_JOB_RUNNING_COUNT_CMD = "qstat -u cipres |grep cipres |grep -v aws |grep -c ' R '";
    //private static final String NONAWS_JOB_RUNNING_CMD = "qstat -u cipres |grep -v aws |grep ' R \\|Username' > ./" + COMET_RUNNING_JOBS_DETAILS;
    //private static final String NONAWS_JOB_INQUEUE_CMD = "qstat -u cipres |grep -v 'aws\\| R ' > ./" + COMET_INQUEUE_JOBS_DETAILS;
    //private static final String NONAWS_JOB_RUNNING_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = R'|grep -v -B 3 -A 2 'queue = aws' > ./" + COMET_RUNNING_JOBS_DETAILS;
    private static final String NONAWS_JOB_RUNNING_CMD = ALL_JOB_RUNNING_CMD + "|grep --no-group-separator -P -B 3 -A 2 'queue = (?!aws)' > ./" + COMET_RUNNING_JOBS_DETAILS;
    //private static final String NONAWS_JOB_INQUEUE_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = C\\|job_state = E\\|job_state = H\\|job_state = Q\\|job_state = T\\|job_state = W\\|job_state = S\\|job_state = U'|grep -v -B 3 -A 2 'queue = aws'  > ./" + COMET_INQUEUE_JOBS_DETAILS;
    private static final String NONAWS_JOB_INQUEUE_CMD = ALL_JOB_INQUEUE_CMD + "|grep --no-group-separator -P -B 3 -A 2 'queue = (?!aws)'  > ./" + COMET_INQUEUE_JOBS_DETAILS;

    private static final String AWS_JOB_COUNT_CMD = "qstat -u cipres |grep cipres |grep -c aws";
    private static final String AWS_JOB_RUNNING_COUNT_CMD = "qstat -u cipres |grep cipres |grep aws |grep -c ' R '";
    //private static final String AWS_JOB_RUNNING_CMD = "qstat -u cipres |grep 'aws\\|Username' |grep ' R \\|Username' > ./" + AWS_RUNNING_JOBS_DETAILS;
    //private static final String AWS_JOB_INQUEUE_CMD = "qstat -u cipres |grep 'aws\\|Username' |grep -v ' R ' > ./" + AWS_INQUEUE_JOBS_DETAILS; 
    //private static final String AWS_JOB_RUNNING_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = R'|grep -B 3 -A 2 'queue = aws' > ./" + AWS_RUNNING_JOBS_DETAILS;
    private static final String AWS_JOB_RUNNING_CMD = ALL_JOB_RUNNING_CMD + "|grep --no-group-separator -B 3 -A 2 'queue = aws' > ./" + AWS_RUNNING_JOBS_DETAILS;
    //private static final String AWS_JOB_INQUEUE_CMD = "qstat -f |grep 'Job Id\\|Job_Name\\|job_state\\|queue\\|qtime\\|euser' |grep --no-group-separator  -B 5 'euser = cipres('|grep --no-group-separator -B 2 -A 3 'job_state = C\\|job_state = E\\|job_state = H\\|job_state = Q\\|job_state = T\\|job_state = W\\|job_state = S\\|job_state = U'|grep -B 3 -A 2 'queue = aws'  > ./" + AWS_INQUEUE_JOBS_DETAILS;
    private static final String AWS_JOB_INQUEUE_CMD = ALL_JOB_INQUEUE_CMD + "|grep --no-group-separator -B 3 -A 2 'queue = aws'  > ./" + AWS_INQUEUE_JOBS_DETAILS;

    private static final String TSCC_JOB_COUNT_CMD = "qstat -u cipres_test |grep cipres| grep -c cipres";
    private static final String TSCC_JOB_RUNNING_COUNT_CMD = "qstat -u cipres_test |grep cipres |grep -c ' R '";
    //private static final String TSCC_JOB_INQUEUE_CMD = "qstat -u cipres_test |grep -v ' R ' > ./" + TSCC_INQUEUE_JOBS_DETAILS;            
    private static final String TSCC_JOB_RUNNING_CMD = ALL_JOB_RUNNING_CMD.replace('(', '_') + "> ./" + TSCC_RUNNING_JOBS_DETAILS;
    //private static final String TSCC_JOB_RUNNING_CMD = "qstat -u cipres_test |grep ' R \\|User' > ./" + TSCC_RUNNING_JOBS_DETAILS;
    private static final String TSCC_JOB_INQUEUE_CMD = ALL_JOB_INQUEUE_CMD.replace('(', '_') + "> ./" + TSCC_INQUEUE_JOBS_DETAILS;
    private static final String LMOD_WARNING = "'~~~~~~~'";
    private String cometRunningJobs = "";
    private String cometInQueueJobs = "";
    private String expanseRunningJobs = "";
    private String expanseInQueueJobs = "";    
    private String awsRunningJobs = "";
    private String awsInQueueJobs = "";
    private String tsccRunningJobs = "";
    private String tsccInQueueJobs = "";

    private int cometRunningCount = -1;
    private int cometInQueueCount = -1;

    private int expanseRunningCount = -1;
    private int expanseInQueueCount = -1;
    
    private int awsRunningCount = -1;
    private int awsInQueueCount = -1;

    private int tsccRunningCount = -1;
    private int tsccInQueueCount = -1;

    private int parserInQueueCount = -1;
    private float avgQueueTime = -1.0f;

    private String searchStr = "";
    private long userId = -1L;
    private String userEmail = "";
    private String userJobHandle = "";

    private String searchStrAA = "";
    private String userEmailAA = "";
    private boolean hasActivated = false;
    // task list form properties
    //private String taskAction;
    // task list page properties
    private Task inputTask;
    private Task outputTask;
    private Map<String, List<TaskInputSourceDocument>> input;
    private Map<String, List<TaskOutputSourceDocument>> output;

    
    private MultipleAccounts ma = new MultipleAccounts();

    // ================================================================
    // Action methods
    // ================================================================
    public String listTasks ()
    {
        logger.debug("BEGIN: execute()::String");

        String retVal = LIST;

        logger.debug(String.format("RetVal=[%s]", retVal));

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

        return retVal;
    }


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

        String retVal = "userJobs";
        TabbedPanel<Task> folderTasks
                = (TabbedPanel<Task>) getSession().get(ADMIN_FOLDER_TASKS);
        if (folderTasks != null)
            searchStr = folderTasks.getFolder().getComment();
        
        logger.debug("END: getJobs()::String");

        return retVal;
    }


    @SkipValidation
    @Override
    public String list ()
    {
        logger.info("BEGIN: list()::String");

        Folder folder = getCurrentFolder();

        if (folder == null)
        {
            logger.error(reportUserError("You must select a folder to view its tasks."));
            return HOME;
        }
        else
        {
            if (isCurrentFolder(folder) == false)
            {
                setCurrentFolder(folder);
            }

            TabbedPanel<Task> tabs = getFolderTaskTabs();
            String tab = getRequestParameter(TAB);

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

            return LIST;
        }
    }


    @SkipValidation
    public String refresh ()
    {
        logger.info("BEGIN: refresh ()::String");
        refreshStatistics();
        return LIST;
    }


    @SkipValidation
    public String getStatistics ()
    {
        refreshStatistics();
        return LIST;
    }


    @SkipValidation
    public String input ()
    {
        refreshFolderTaskTabs();
        return INPUT;
    }


    @SkipValidation
    public String getAccountActivation ()
    {
        return ACCOUNTACTIVATION;
    }
    
    @SkipValidation
    public String searchAccountActivation ()
    {
        return INPUT;
    }

    
    @SkipValidation
    public boolean anyReportFound ()
    {
        return ma.anyReportFound();
 
    }

    @SkipValidation
    public boolean hasBlockedAccounts ()
    {
        return ma.hasBlockedAccounts();
 
    }
    
    @SkipValidation
    public String getBlockedAccounts ()
    {
        return ma.getBlockedAccounts();
 
    }
    
    @SkipValidation
    public boolean hasUnblockedAccounts ()
    {
        return ma.hasUnblockedAccounts();
 
    }
    
    @SkipValidation
    public String getUnblockedAccounts ()
    {
        return ma.getUnblockedAccounts();
 
    }       
    
    @SkipValidation
    public void setPreviousReportDate(String pReportDate)
    {
        ma.setPreviousReportDate(pReportDate);
    }
        
    @SkipValidation
    public String blockMultipleAccounts()
    {
        ActionContext context = ActionContext.getContext();
        
        Map<String, Object> params = context.getParameters();
        if (!ma.blockMultipleAccounts(params))
            addActionError("Please select at least one account to block");
        ma.searchMultipleAccountReportPrevious();
        /*
        if (params != null)
        {
            Set<Map.Entry<String, Object>> entries = params.entrySet();
            if (entries != null)
            {
                for (Map.Entry<String, Object> e : entries)
                {
                    logger.info("Parameters key = " + e.getKey());
                    Object obj = e.getValue();
                    if (obj instanceof String[])
                    {
                        String[] ss = (String[])obj;
                        for (String si: ss)
                            logger.info(" value = " + si);
                    }                  
                    //logger.info("Parameters key = " + e.getKey() + " value = " + ((Boolean)e.getValue()));
                }
            }
        }*/
        //String userId = findParam("idUser", params);       
        return MULTIPLEACCOUNTS;
    }
    
    @SkipValidation
    public String searchMultipleAccountReport ()
    {
        ma.searchMultipleAccountReport();
        return MULTIPLEACCOUNTS;
    }
    
    @SkipValidation
    public String getMultipleAccounts ()
    {
        ma.loadMultipleAccountsList();
        return MULTIPLEACCOUNTS;
    }
    
    @SkipValidation
    public List<MultipleAccounts.AccountInfo> getMultipleAccountsList ()
    {
        //loadMultipleAccountsList();
        return ma.getMultipleAccountsList();
    }
    
    @SkipValidation
    public void setSearchMAStr(String searchMA)
    {
        ma.setSearchMAStr(searchMA);
    }
    
    @SkipValidation
    public String getSearchMAStr()
    {
        return (ma.getSearchMAStr());
    }
    
    @SkipValidation
    public String getReportDate()
    {
        logger.debug("BEGIN: getReportDate()::String");
        
        String reportDate = ma.getReportDate();
        logger.info("reportDate = " + reportDate);
        return reportDate;
    } 

    @SkipValidation
    public String unblockUser ()
    {
        ActionContext context = ActionContext.getContext();
        
        Map<String, Object> params = context.getParameters();
        
        String user = null;
        if ((user = ma.unblockUser(params)) != null)
            addActionError("Error: failed to unblock " + user);
        ma.searchMultipleAccountReportPrevious();
        
        return MULTIPLEACCOUNTS;
    }    
    
    @SkipValidation
    public String activateAccountOnBehalfOfUser ()
    {
        try
        {
            User targetUser = User.findUser(null,this.searchStrAA, false, true);

            if (targetUser != null)
            {
                targetUser.setActivationCode(null);
                targetUser.save();
                hasActivated = true;
                addActionMessage("User account associated with email address " + this.userEmailAA + " has been activated successfully");
            }
            else
            {
                hasActivated = false;
                clearActionErrors();
                addActionError("Error occurred when trying to activate account associated with email address " + userEmailAA);                    
            }
        }
        catch ( Exception ex )
        {
            logger.error(ex);
            clearActionErrors();
            addActionError("Error occurred when trying to activate account associated with email address " + userEmailAA); 
        }        
        return ACCOUNTACTIVATION;
    }    
    
    @SkipValidation
    public String refreshUserJobs ()
    {
        logger.info("BEGIN: refreshUserJobs()::String");
        getFolderTaskTabs();
        setSearchStr(this.searchStr);
        refreshFolderTaskTabs();

        return LIST;
    }


    @SkipValidation
    public String getCometRunningJobs ()
    {
        return "<pre class=\"source\">" + cometRunningJobs + "</pre>";
    }


    @SkipValidation
    public String getCometInQueueJobs ()
    {
        return "<pre class=\"source\">" + cometInQueueJobs + "</pre>";
    }

    @SkipValidation
    public String getExpanseRunningJobs ()
    {
        return "<pre class=\"source\"><span style=\"font-size: 12px\">" + expanseRunningJobs + "</span></pre>";
    }


    @SkipValidation
    public String getExpanseInQueueJobs ()
    {
        return "<pre class=\"source\"><span style=\"font-size: 12px\">" + expanseInQueueJobs + "</span></pre>";
    }

    @SkipValidation
    public String getAwsRunningJobs ()
    {
        return "<pre class=\"source\">" + awsRunningJobs + "</pre>";
    }


    @SkipValidation
    public String getAwsInQueueJobs ()
    {
        return "<pre class=\"source\">" + awsInQueueJobs + "</pre>";
    }


    @SkipValidation
    public String getTsccRunningJobs ()
    {
        return "<pre class=\"source\">" + tsccRunningJobs + "</pre>";
    }


    @SkipValidation
    public String getTsccInQueueJobs ()
    {
        return "<pre class=\"source\">" + tsccInQueueJobs + "</pre>";
    }


    @SkipValidation
    public String getJobDetailsCometInQueue ()
    {
        cometInQueueJobs = getCometJobDetails(NONAWS_JOB_INQUEUE_CMD, COMET_INQUEUE_JOBS_DETAILS, COMET);
        return CRJ;
    }


    @SkipValidation
    public String getJobDetailsCometRunning ()
    {
        cometRunningJobs = getCometJobDetails(NONAWS_JOB_RUNNING_CMD, COMET_RUNNING_JOBS_DETAILS, COMET);
        return CRJ;
    }

    @SkipValidation
    public String getJobDetailsExpanseInQueue ()
    {
        expanseInQueueJobs = getCometJobDetails(EXPANSE_JOB_INQUEUE_CMD, EXPANSE_INQUEUE_JOBS_DETAILS, EXPANSE);
        return CRJ;
    }


    @SkipValidation
    public String getJobDetailsExpanseRunning ()
    {
        expanseRunningJobs = getCometJobDetails(EXPANSE_JOB_RUNNING_CMD, EXPANSE_RUNNING_JOBS_DETAILS, EXPANSE);
        return CRJ;
    }
    
    @SkipValidation
    public String getJobDetailsAwsInQueue ()
    {
        awsInQueueJobs = getCometJobDetails(AWS_JOB_INQUEUE_CMD, AWS_INQUEUE_JOBS_DETAILS, COMET);
        return CRJ;
    }


    @SkipValidation
    public String getJobDetailsAwsRunning ()
    {
        awsRunningJobs = getCometJobDetails(AWS_JOB_RUNNING_CMD, AWS_RUNNING_JOBS_DETAILS, COMET);
        return CRJ;
    }


    @SkipValidation
    public String getJobDetailsTsccInQueue ()
    {
        tsccInQueueJobs = getTsccJobDetails(TSCC_JOB_INQUEUE_CMD, TSCC_INQUEUE_JOBS_DETAILS);
        return CRJ;
    }


    @SkipValidation
    public String getJobDetailsTsccRunning ()
    {
        tsccRunningJobs = getTsccJobDetails(TSCC_JOB_RUNNING_CMD, TSCC_RUNNING_JOBS_DETAILS);
        return CRJ;
    }


    @SkipValidation
    @Override
    public String cancel ()
    {
        String taskAction = getTaskAction();
        if (taskAction == null)
        {
            addActionError("You must select an action to manipulate your tasks.");
        }
        else
        {
            Long[] selectedIds = getSelectedIds();
            if (selectedIds == null || selectedIds.length < 1)
            {
                addActionError("You must select one or more tasks to "
                        + taskAction.toLowerCase() + " them.");
            }
            else
            {
                /*
                 *
                 */
                String[] button = (String[]) getParameters().get("method:cancel");
                if (button != null && button.length > 0 && button[0].equals(DELETE))
                {
                    return deleteSelected();
                }
                /*
                 *
                 */
                Folder folder = getCurrentFolder();
                Long targetFolder = getTargetFolder();
                if (folder == null)
                {
                    addActionError("Current folder is null");
                }
                else
                {
                    if (targetFolder == null)
                    {
                        addActionError("You must select a target folder to "
                                + taskAction.toLowerCase() + " your tasks.");
                    }
                    else if (targetFolder.equals(folder.getFolderId()))
                    {
                        addActionError("You must select a new folder to "
                                + taskAction.toLowerCase() + " your tasks into.");
                    }
                    else if (taskAction.equalsIgnoreCase(MOVE))
                    {
                        int moved = moveSelectedTasks();
                        String result = moved
                                + " task";
                        if (moved != 1)
                        {
                            result += "s were ";
                        }
                        else
                        {
                            result += " was ";
                        }
                        result += "successfully moved.";
                        reportUserMessage(result);
                        refreshFolderTaskTabs();
                    }
                    else
                    {
                        addActionError("You have requested an unrecognized task action, "
                                + "please select from the list below.");
                    }
                }
            }
        }
        return LIST;
    }


    @Override
    public synchronized Folder getCurrentFolder ()
    {
        try
        {
            if (invisibleFolder != null)
            {
                return invisibleFolder;
            }
            else
            {
                WorkbenchSession session = getWorkbenchSession();
                if (session != null)
                {

                    invisibleFolder = new Folder(session.getUser());
                    return invisibleFolder;
                }
            }
        }
        catch ( Exception e )
        {
            logger.error(e.toString());
        }
        return null;
    }


    public String getCometRunningCount ()
    {
        return formatNumber(cometRunningCount);
    }


    public String getCometInQueueCount ()
    {
        return formatNumber(cometInQueueCount);
    }

    public String getExpanseRunningCount ()
    {
        return formatNumber(expanseRunningCount);
    }


    public String getExpanseInQueueCount ()
    {
        return formatNumber(expanseInQueueCount);
    }
    

    public String getAwsRunningCount ()
    {
        return formatNumber(awsRunningCount);
    }


    public String getAwsInQueueCount ()
    {
        return formatNumber(awsInQueueCount);
    }


    public String getTsccRunningCount ()
    {
        return formatNumber(tsccRunningCount);
    }


    public String getTsccInQueueCount ()
    {
        return formatNumber(tsccInQueueCount);
    }


    public String getParserInQueueCount ()
    {
        return formatNumber(parserInQueueCount);
    }


    public String getAvgQueueTime ()
    {
        return formatNumber(avgQueueTime);
    }


    private String formatNumber ( Number num )
    {
        if (num.doubleValue() >= 0.0)
        {
            return num.toString();
        }
        else
        {
            return NOT_AVAILABLE;
        }
    }


    public void setSearchStr ( String searchStr )
    {
        logger.info("setSearchStr::searchStr = " + searchStr);
        if (searchStr == null)
        {
            return;
        }

        this.searchStr = searchStr.trim();

        if (this.searchStr.contains(".") && this.searchStr.contains("@"))
        {
            try
            {
                User targetUser = User.findUserByEmail(this.searchStr);

                if (targetUser != null)
                {
                    userId = targetUser.getUserId();
                    userEmail = this.searchStr;
                }
                else
                {
                    userId = -1L;
                    userEmail = "";
                }
                userJobHandle = "";
            }
            catch ( Exception ex )
            {
                logger.error(ex);
                userEmail = "";
                userId = -1L;
                userJobHandle = "";
            }
        }
        else if (this.searchStr.startsWith("NGBW-JOB-"))
        {
            userJobHandle = this.searchStr;
            userId = -1L;
            userEmail = "";
        }
        else
        {
            try
            {
                User targetUser = User.findUser(this.searchStr);

                if (targetUser != null)
                {
                    userId = targetUser.getUserId();
                }
                else
                {
                    userId = -1L;
                }

                userEmail = "";
                userJobHandle = "";
            }
            catch ( Exception ex )
            {
                logger.error(ex);
                userEmail = "";
                userId = -1L;
                userJobHandle = "";
            }
        }

    }

    public void setSearchStrAA ( String searchStr )
    {
        logger.info("setSearchStrAA::searchStr = " + searchStr);
        if (searchStr == null)
        {
            return;
        }

        this.searchStrAA = searchStr.trim();

        if (this.searchStrAA.contains(".") && this.searchStrAA.contains("@"))
        {
            try
            {
                User targetUser = User.findUser(null,this.searchStrAA, false, true);

                if (targetUser != null)
                {
                    userEmailAA = this.searchStrAA;
                    hasActivated = (targetUser.getActivationCode() == null);
                }
                else
                {
                    userEmailAA = "";
                    hasActivated = false;
                    clearActionErrors();
                    addActionError("No user with that email address can be found in the database. Please make sure you enter the correct email address for current environment (Beta or Production).");                    
                }
            }
            catch ( Exception ex )
            {
                logger.error(ex);
                userEmailAA = "";
            }
        }
        else
        {
            clearActionErrors();
            addActionError("The email address entered has an invalid format");                             
        }
    }

    public boolean hasSearchStrAA()
    {
        return (searchStrAA != null && !searchStrAA.isEmpty());
    }
    
    public boolean isUserFound()
    {
        return (userEmailAA != null && !userEmailAA.isEmpty());
    }
    
    public boolean hasAccountActivated()
    {
        return hasActivated;
    }
    
    public String getSearchStrAA ()
    {
        logger.info("getSearchStr::searchStrAA = " + searchStrAA);
        return searchStrAA;
    }


    public String getSearchStr ()
    {
        logger.info("getSearchStr::searchStr = " + searchStr);
        return searchStr;
    }


    @SuppressWarnings("unchecked")
    public TabbedPanel<Task> getFolderTaskTabs ()
    {
        TabbedPanel<Task> folderTasks
                = (TabbedPanel<Task>) getSession().get(ADMIN_FOLDER_TASKS);
        if (folderTasks == null)
        //|| folderTasks.isParentFolder(getCurrentFolder()) == false)
        {
            folderTasks = refreshFolderTaskTabs();
        }
        else
        {
            searchStr = folderTasks.getFolder().getComment();
        }
        return folderTasks;
    }


    @SuppressWarnings("unchecked")
    public void setFolderTaskTabs ( TabbedPanel<Task> folderTasks )
    {
        if (folderTasks != null)
        {
            folderTasks.getFolder().setComment(searchStr);
            getSession().put(ADMIN_FOLDER_TASKS, folderTasks);
        }
        else
        {
            getSession().remove(ADMIN_FOLDER_TASKS);
        }
    }


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

        String label = null;

        UserDataItem currData = getCurrentData();

        if (currData != null)
        {
            label = getLabel(currData);
        }

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


    public boolean isJobHandleEmpty ( Task task )
    {
        if (task == null)
        {
            return true;
        }
        else
        {
            return truncateText(task.getJobHandle() == null ? "" : task.getJobHandle()).isEmpty();
        }
    }


    public TabbedPanel<Task> refreshFolderTaskTabs ()
    {
        try
        {
            Folder folder = getCurrentFolder();

            if (folder == null)
            {
                throw new NullPointerException("No folder is currently selected.");
            }
            else
            {
                //TODO: Add support for multiple task tab categories
                //List<Task> taskList = folder.findTasks();
                logger.info("refreshFolderTaskTabs: userId = " + userId);
                List<Task> taskList = null;

                if (userId > 0L)
                {
                    taskList = Task.findTasksByUserId(userId);
                }
                //taskList = Task.findTasksByUserIdAge(userId, 21);
                else if (userJobHandle != null && !userJobHandle.isEmpty())
                {
                    Task t = Task.findTaskByJobHandle(userJobHandle);
                    if (t != null)
                    {
                        taskList = new ArrayList<Task>();
                        taskList.add(Task.findTaskByJobHandle(userJobHandle));
                    }
                    else
                    {
                        Statistics s = Statistics.find(userJobHandle, 1);
                        if (s != null)
                        {
                            clearActionErrors();
                            //Collection<String> errors = getActionErrors();
                            String errorMsg = userJobHandle + " doesn't exist in tasks table but exists in job_stats table. The job probably has been deleted by user.";
                            //if (!errors.contains(errorMsg))
                            addActionError(errorMsg);                    
                        }
                        else
                        {
                            clearActionErrors();
                            addActionError(userJobHandle + " doesn't exist in either tasks table or job_stats table. Please make sure you have the correct job handle for current environment (Beta or Production).");
                        }
                    }
                }
                if (taskList != null)
                {
                    getWorkbenchSession().sortTasks(taskList, TaskSortableField.ID, true);
                }

                TabbedPanel<Task> folderTasks = null;

                if (taskList != null && !taskList.isEmpty())
                {
                    folderTasks = new TabbedPanel<Task>(folder);

                    List<Tab<Task>> taskTabs = new Vector<Tab<Task>>(1);

                    Page<Task> taskPage = new ListPage<Task>(taskList);

                    Tab<Task> taskTab = new Tab<Task>(taskPage, "Tasks");
                    taskTabs.add(taskTab);

                    folderTasks.setTabs(new ListPage<Tab<Task>>(taskTabs));
                    folderTasks.sortTabs();
                }

                setFolderTaskTabs(folderTasks);
                //refreshFolders();
                return folderTasks;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving tabbed folder tasks", error);
            return null;
        }
    }


    private void refreshStatistics ()
    {
        ToolResource tr = Workbench.getInstance().getServiceFactory().getToolRegistry().getToolResource(COMET);

        logger.info("refreshStatistics(): " + (tr == null ? "null" : "not null"));
        if (tr != null)
        {
            String login = tr.getParameters().get(new String("login"));
            //int dotChar = login.indexOf('.');
            //int atChar = login.indexOf('@');

            //if (dotChar > -1 && atChar > -1 && (dotChar > atChar))
            {
                //login = login.substring(atChar+1, dotChar);
                logger.info("Statistics login = " + login);
                if (login != null && !login.isEmpty())
                {
                    //SSHExecProcessRunner runner;
                    //Class<SSHExecProcessRunner> runnerClass;
                    //String className = "org.ngbw.sdk.common.util.SSHExecProcessRunner";

                    GsiSSHProcessRunner runner = null;
                    try
                    {
                        //runnerClass = (Class<SSHExecProcessRunner>) Class.forName(className);

                        //runner = runnerClass.newInstance();
                        runner = new GsiSSHProcessRunner();
                        HashMap<String, String> cfg = new HashMap<String, String>();
                        cfg.put(LOGIN, login);

                        if (runner.configure(cfg))
                        {
                            //int ret = runner.run(NONAWS_JOB_COUNT_CMD);
                            Future<Integer> result = runner.start(NONAWS_JOB_COUNT_CMD + ";" + NONAWS_JOB_RUNNING_COUNT_CMD + ";" + AWS_JOB_COUNT_CMD + ";" + AWS_JOB_RUNNING_COUNT_CMD);
                            logger.info("Command to run:" + NONAWS_JOB_COUNT_CMD + ";" + NONAWS_JOB_RUNNING_COUNT_CMD + ";" + AWS_JOB_COUNT_CMD + ";" + AWS_JOB_RUNNING_COUNT_CMD);
                            int exitCode = result.get();
                            if (exitCode == 0 || exitCode == 1)
                            {
                                String numStr = runner.getStdOut();
                                logger.info("stdout=" + numStr);
                                String[] nums = numStr.split("\n");
                                if (nums != null)
                                {
                                    int allJobsCount = -1;
                                    int allAWSJobsCount = -1;
                                    if (nums.length > 0)
                                    {
                                        allJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                    }
                                    //    cometRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                    if (nums.length > 1)
                                    {
                                        cometRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[1]));
                                    }

                                    if (allJobsCount > -1 && cometRunningCount > -1)
                                    {
                                        cometInQueueCount = allJobsCount - cometRunningCount;
                                    }

                                    if (nums.length > 2)
                                    {
                                        allAWSJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[2]));
                                    }
                                    //    cometRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                    if (nums.length > 3)
                                    {
                                        awsRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[3]));
                                    }

                                    if (allAWSJobsCount > -1 && awsRunningCount > -1)
                                    {
                                        awsInQueueCount = allAWSJobsCount - awsRunningCount;
                                    }
                                }
                            }
                            else
                            {
                                logger.info("exitCode=" + exitCode);
                                String numStr = runner.getStdOut();
                                logger.info("stdout=" + numStr);
                            }
                        }
                    }
                    catch ( Exception e )
                    {
                        logger.error("", e);
                    }
                }
            }
        }

        ToolResource trExpanse = Workbench.getInstance().getServiceFactory().getToolRegistry().getToolResource(EXPANSE);

        logger.info("refreshStatistics(): " + (trExpanse == null ? "trExpanse is null" : "trExpanse is not null"));
        if (trExpanse != null)
        {
            String login = trExpanse.getParameters().get(new String("login"));

            logger.info("Statistics Expanse login = " + login);
            if (login != null && !login.isEmpty())
            {
                //SSHExecProcessRunner runner;
                //Class<SSHExecProcessRunner> runnerClass;
                //String className = "org.ngbw.sdk.common.util.SSHExecProcessRunner";

                GsiSSHProcessRunner runner = null;
                try
                {
                    //runnerClass = (Class<SSHExecProcessRunner>) Class.forName(className);

                    //runner = runnerClass.newInstance();
                    runner = new GsiSSHProcessRunner();
                    HashMap<String, String> cfg = new HashMap<String, String>();
                    cfg.put(LOGIN, login);

                    if (runner.configure(cfg))                           
                    {
                        Future<Integer> result = runner.start(EXPANSE_JOB_COUNT_CMD + ";" + EXPANSE_JOB_RUNNING_COUNT_CMD);
                        logger.info("Command to run:" + EXPANSE_JOB_COUNT_CMD + ";" + EXPANSE_JOB_RUNNING_COUNT_CMD);
                        int exitCode = result.get();
                        if (exitCode == 0 || exitCode == 1)
                        {
                            String numStr = runner.getStdOut();
                            logger.info("stdout=" + numStr);
                            String[] nums = numStr.split("\n");
                            if (nums != null)
                            {
                                int allJobsCount = -1;
                                
                                if (nums.length > 1)
                                {
                                    allJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[nums.length-2]));
                                    expanseRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[nums.length-1]));
                                }
                                else if (nums.length > 0)
                                {
                                    allJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[nums.length-1]));
                                }

                                /*
                                if (nums.length > 0)
                                {
                                    allJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                }

                                if (nums.length > 1)
                                {
                                    expanseRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[1]));
                                }
                                */

                                if (allJobsCount > -1 && expanseRunningCount > -1)
                                {
                                    expanseInQueueCount = allJobsCount - expanseRunningCount;
                                }
                            }
                        }
                        else
                        {
                            logger.info("expanse exitCode=" + exitCode);
                            String numStr = runner.getStdOut();
                            logger.info("expanse stdout=" + numStr);
                        }
                    }
                }
                catch ( Exception e )
                {
                    logger.error("", e);
                }                
            }
        }
            
        ToolResource trTscc = Workbench.getInstance().getServiceFactory().getToolRegistry().getToolResource(TSCC);
        if (trTscc != null)
        {
            String login = trTscc.getParameters().get(new String("login"));
            //int dotChar = login.indexOf('.');
            //int atChar = login.indexOf('@');
            logger.info("Statistics TSCC login = " + login);

            //if (dotChar > -1 && atChar > -1 && (dotChar > atChar))
            {
                //login = login.substring(atChar+1, dotChar);
                logger.info("Statistics TSCC login = " + login);
                if (login != null && !login.isEmpty())
                {
                    SSHExecProcessRunner runner;
                    Class<SSHExecProcessRunner> runnerClass;
                    String className = "org.ngbw.sdk.common.util.SSHExecProcessRunner";
                    try
                    {
                        runnerClass = (Class<SSHExecProcessRunner>) Class.forName(className);

                        runner = runnerClass.newInstance();

                        HashMap<String, String> cfg = new HashMap<String, String>();
                        cfg.put(LOGIN, login);

                        if (runner.configure(cfg))
                        {
                            int ret = runner.run(TSCC_JOB_COUNT_CMD + ";" + TSCC_JOB_RUNNING_COUNT_CMD);
                            //int ret = runner.run("source /home/cipres_test/ngbw/contrib/scripts/workbench.rc;" + TSCC_JOB_COUNT_CMD);
                            //Future<Integer> result = runner.start(TSCC_JOB_COUNT_CMD);
                            //Future<Integer> result2 = runner.start(TSCC_JOB_RUNNING_COUNT_CMD);
                            logger.info("Command to run:" + TSCC_JOB_COUNT_CMD + ";" + TSCC_JOB_RUNNING_COUNT_CMD);
                            //int exitCode = result.get();
                            //int exitCode2 = result2.get();
                            String numStr = runner.getStdOut();

                            logger.info("stdout=" + numStr);
                            if (ret == 0 || ret == 1)
                            {
                                //String numStr = runner.getStdOut();

                                logger.info("stdout=" + numStr);
                                String[] nums = numStr.split("\n");
                                if (nums != null)
                                {
                                    int allJobsCount = -1;
                                    if (nums.length > 0)
                                    {
                                        allJobsCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                    }
                                    //    cometRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[0]));
                                    if (nums.length > 1)
                                    {
                                        tsccRunningCount = Integer.parseInt(org.apache.commons.lang.StringUtils.chomp(nums[1]));
                                    }

                                    if (allJobsCount > -1 && tsccRunningCount > -1)
                                    {
                                        tsccInQueueCount = allJobsCount - tsccRunningCount;
                                    }
                                }

                            }
                            else
                            {
                                logger.info("exitCode=" + ret);
                            }
                        }
                    }
                    catch ( Exception e )
                    {
                        logger.error("", e);
                    }
                }
            }
        }

        refreshParserInQueue();
    }


    private String getCometJobDetails ( String command, String fileName, String resourceName )
    {
        String jobs = "";
        ToolResource tr = Workbench.getInstance().getServiceFactory().getToolRegistry().getToolResource(resourceName);

        logger.info("refreshStatistics(): " + (tr == null ? "null" : "not null"));
        if (tr != null)
        {
            String login = tr.getParameters().get(new String("login"));
            //login = login.substring(atChar+1, dotChar);
            logger.info("Statistics login = " + login);
            if (login != null && !login.isEmpty())
            {
                //SSHExecProcessRunner runner;
                //Class<SSHExecProcessRunner> runnerClass;
                //String className = "org.ngbw.sdk.common.util.SSHExecProcessRunner";

                GsiSSHProcessRunner runner = null;
                try
                {
                    //runnerClass = (Class<SSHExecProcessRunner>) Class.forName(className);

                    //runner = runnerClass.newInstance();
                    runner = new GsiSSHProcessRunner();
                    HashMap<String, String> cfg = new HashMap<String, String>();
                    cfg.put(LOGIN, login);

                    if (runner.configure(cfg))
                    {
                        //int ret = runner.run(NONAWS_JOB_COUNT_CMD);
                        //Future<Integer> result = runner.start(NONAWS_JOB_RUNNING_CMD + ";" + "wc -l ./" + COMET_RUNNING_JOBS_DETAILS);
                        Future<Integer> result = runner.start(command + ";" + "wc -l ./" + fileName);
                        logger.info("Command to run: " + command + ";" + "wc -l ./" + fileName);
                        int exitCode = result.get();
                        if (exitCode == 0)
                        {
                            String countStr = runner.getStdOut();
                            logger.info("stdout=" + countStr);
                            String[] counts = countStr.split("\n");
                            if (counts != null && counts.length > 0)
                            {
                                String last = counts[counts.length-1];
                                String[] lasts = last.split(" ");
                                if (lasts != null && lasts.length > 0)
                                {
                                    int count = Integer.parseInt(lasts[0]);

                                    int step = 28;
                                    for (int run = 1; run <= count; run = run + step + 1)
                                    {
                                        result = runner.start("echo " + LMOD_WARNING + " ; sed -n " + run + "," + (run + step) + "p ./" + fileName);
                                        if (result.get() == 0)
                                        {
                                            String output = runner.getStdOut();
                                            String outputs[] = output.split(LMOD_WARNING.substring(1, LMOD_WARNING.length()-1)+"\n");
                                            if (outputs != null && outputs.length > 0)
                                            jobs += outputs[outputs.length-1];                                       
                                            //logger.info("stdout=" + jobs);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                catch ( Exception e )
                {
                    logger.error("", e);
                }
            }
        }
        return jobs;

    }


    private String getTsccJobDetails ( String command, String fileName )
    {
        String jobs = "";
        ToolResource trTscc = Workbench.getInstance().getServiceFactory().getToolRegistry().getToolResource(TSCC);

        if (trTscc != null)
        {
            String login = trTscc.getParameters().get(new String("login"));
            //int dotChar = login.indexOf('.');
            //int atChar = login.indexOf('@');
            logger.info("Statistics TSCC login = " + login);

            //if (dotChar > -1 && atChar > -1 && (dotChar > atChar))
            {
                //login = login.substring(atChar+1, dotChar);
                logger.info("Statistics TSCC login = " + login);
                if (login != null && !login.isEmpty())
                {
                    SSHExecProcessRunner runner;
                    Class<SSHExecProcessRunner> runnerClass;
                    String className = "org.ngbw.sdk.common.util.SSHExecProcessRunner";
                    try
                    {
                        runnerClass = (Class<SSHExecProcessRunner>) Class.forName(className);

                        runner = runnerClass.newInstance();

                        HashMap<String, String> cfg = new HashMap<String, String>();
                        cfg.put(LOGIN, login);

                        if (runner.configure(cfg))
                        {
                            int ret = runner.run(command + ";" + "wc -l ./" + fileName);
                            //int ret = runner.run("source /home/cipres_test/ngbw/contrib/scripts/workbench.rc;" + TSCC_JOB_COUNT_CMD);
                            //Future<Integer> result = runner.start(TSCC_JOB_COUNT_CMD);
                            //Future<Integer> result2 = runner.start(TSCC_JOB_RUNNING_COUNT_CMD);
                            logger.info("Command to run:" + command + ";" + "wc -l ./" + fileName);
                            //int exitCode = result.get();
                            //int exitCode2 = result2.get();
                            //Future<Integer> result = runner.start(command + ";" + "wc -l ./" + fileName);                        
                            //logger.info("Command to run: " + command + ";" + "wc -l ./" + fileName);
                            //int exitCode = result.get();
                            if (ret == 0 || ret == 1)
                            {
                                String countStr = runner.getStdOut();
                                logger.info("stdout=" + countStr);
                                String[] counts = countStr.split(" ");
                                if (counts != null && counts.length > 0)
                                {
                                    int count = Integer.parseInt(counts[0]);

                                    int step = 89;
                                    for (int run = 1; run <= count; run = run + step + 1)
                                    {
                                        ret = runner.run("sed -n " + run + "," + (run + step) + "p ./" + fileName);
                                        if (ret == 0 || ret == 1)
                                        {
                                            jobs += runner.getStdOut();
                                            //logger.info("stdout=" + jobs);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                logger.info("exitCode=" + ret);
                            }
                        }
                    }
                    catch ( Exception e )
                    {
                        logger.error("", e);
                    }
                }
            }
        }
        return jobs;
    }


    private void refreshParserInQueue ()
    {
        /*
         * try
         * {
         * if (!m_dbConn.isValid(22))
         * m_dbConn = ConnectionManager.getConnectionSource().getConnection();
         * }
         * catch (SQLException sqlEx)
         * {
         * sqlEx.printStackTrace();
         * }
         */
        Connection dbConn = null;
        String stmt = "SELECT COUNT(*) FROM data_parsing_schedule WHERE END_TIME IS NULL";
        String stmt2 = "select AVG(TIMESTAMPDIFF(SECOND, queued_time, start_time)) from data_parsing_schedule where queued_time >= DATE_SUB(CURDATE(), INTERVAL 7 DAY)";
        PreparedStatement selectStmt = null;
        ResultSet resultRows = null;
        PreparedStatement selectStmt2 = null;
        ResultSet resultRows2 = null;
        try
        {
            dbConn = ConnectionManager.getConnectionSource().getConnection();
            selectStmt = dbConn.prepareStatement(stmt);
            resultRows = selectStmt.executeQuery();

            while (resultRows.next())
            {
                parserInQueueCount = resultRows.getInt(1);
            }

            selectStmt2 = dbConn.prepareStatement(stmt2);
            resultRows2 = selectStmt2.executeQuery();

            while (resultRows2.next())
            {

                avgQueueTime = resultRows2.getFloat(1);
                if (avgQueueTime == 0.0f && resultRows2.wasNull())
                {
                    avgQueueTime = -1.0f;
                }
            }
        }
        catch ( Exception ex )
        {
            logger.error(ex);
        }
        finally
        {
            try
            {
                if (resultRows != null)
                {
                    resultRows.close();
                }
                if (selectStmt != null)
                {
                    selectStmt.close();
                }
                if (dbConn != null)
                {
                    dbConn.close();
                }
            }
            catch ( SQLException sqlEx2 )
            {
                logger.error(sqlEx2);
            }
        }
    }

}