Metacat

.content-subsection {

	vertical-align: middle;

	margin: 0px 0px 0px 195px;

}

.content-subsection-header {

 * tpc search result specific settings

 **********************************************************************/

.col1 {

	width: 210px;

	text-align: left;

}

.col4 {

}

.col5 {

	border-right: none;

}

			<div class="col col2">Status</div>

			<div class="col col3">Start Time</div>

			<div class="col col4">Interval</div>

		</div>	

		<!-- div>jobs: <xsl:number value="count(scheduledWorkflowResultset/scheduledJob)" />	</div -->	

		<!-- This tests to see if there are returned documents,

						<xsl:value-of select='./intervalValue' /><xsl:value-of select='./intervalUnit' /> 		

					</div>

					<div class="col col5">	

						<a>

							<xsl:choose>

							<xsl:when test="./status = 'scheduled'">

						<div class="field-suffix"><%= TimeZone.getDefault().getDisplayName(true, TimeZone.SHORT) %> &nbsp;&nbsp;(mm/dd/yyyy hh:mm:ss)</div>

					</div>

					<div class="form-input-row">

						<div class="field-label" id='interval-label' >Interval: </div>  

						<input class="int-input" name='intervalvalue' id='intervalvalue' /> 

						<select class="dropdown-input" name='intervalunit'>

  group_name VARCHAR(512) NOT NULL,

  class_name VARCHAR(1024) NOT NULL,

  start_time TIMESTAMP NOT NULL,

  interval_value INT NOT NULL,

  interval_unit VARCHAR(8) NOT NULL,

  CONSTRAINT scheduled_job_pk PRIMARY KEY (id),

import org.kepler.executionWS.KeplerWebServiceLocator;

import org.kepler.executionWS.KeplerWebServicePortType;

public class WorkflowJob implements InterruptableJob {

	private static Logger logMetacat = Logger.getLogger(WorkflowJob.class);

				throw new JobExecutionException("WorkflowJob.execute - Could not get job data map from job detail"); 

			}

			// the kar lsid must be part of the job data map

			if (karLSID == null) {

			}

			// Locate service

			KeplerWebServiceLocator serviceLocator = new KeplerWebServiceLocator();

			// get endpoint service

			KeplerWebServicePortType serviceEndpoint = serviceLocator.getKeplerWebServiceHttpSoap11Endpoint();

			// call execute against remote endpoint

			logMetacat.debug("WorkflowJob.execute - Executing with kar lsid:" + karLSID);

			logMetacat.debug("WorkflowJob.execute - Status: " + status);

		} catch (RemoteException re) {

		String delays[] = params.get("delay");

		String startTimes[] = params.get("starttime");

		HashMap<String, String> jobParams = new HashMap<String, String>();

		Calendar startCal = null;

		try {

			SchedulerService schedulerService = SchedulerService.getInstance();

				// if delay and starttime were not provided, set date to now.

				startCal = Calendar.getInstance();

			}

			// interval value must exist

			String intervalValues[] = params.get("intervalvalue");

			}

			String intervalUnit = intervalUnits[0];

			String workflowids[] = params.get("workflowid");

			if (workflowids == null || workflowids.length == 0) {

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - workflowid field must be populated "

					+ Calendar.getInstance().getTimeInMillis();

			// Schedule the job

					WORKFLOW_JOB_CLASS, WORKFLOW_JOB_GROUP, jobParams, username, groups);

			// if there is a forwardto param on the request, then send the user to the page

	private String _groupName;

	private String _className;

	private Timestamp _startTime;

	private int _intervalValue;

	private String _intervalUnit;

	private HashMap<String, ScheduledJobParamDAO> _jobParams = new HashMap<String, ScheduledJobParamDAO>();

		_startTime = startTime;

	}

	// get the interval value

	public int getIntervalValue() {

		return _intervalValue;

		Calendar startTimeCal = Calendar.getInstance();

        startTimeCal.setTime(jobDAO.getStartTime());

        // extract the job parameters from their data objects and put into a string map

        HashMap<String, String> jobParams = new HashMap<String, String>();

        HashMap<String, ScheduledJobParamDAO> jobParamDAOs = jobDAO.getAllJobParams();

        }

        // schedule the job

	}

	/**

	 *            the user's group name

	 * @return a message saying that the job was scheduled

	 */

			String username, String[] groups) throws ServiceException {

        Class<Job> jobClass = null;

					+ ", interval unit: " + intervalUnit);

			// start the job in the job scheduler

					jobParams);

			// get a database access object and create the job in the database

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

					intervalValue, intervalUnit, jobParams);

		} catch (AccessException ae) {

			try {

			Calendar startCal = Calendar.getInstance();

	        startCal.setTime(jobDAO.getStartTime());

	        HashMap<String, String> jobParams = new HashMap<String, String>();

	        HashMap<String, ScheduledJobParamDAO> jobParamDAOs = jobDAO.getAllJobParams();

	        for (String paramName : jobParamDAOs.keySet()) {

	        		+ ", interval unit: " + jobDAO.getIntervalUnit());  

	        // start the job in the scheduler

			// update the status in the database

			jobDAO.setStatus(StatusUtil.SCHEDULED);

	 * @param groups

	 *            the user's group name

	 */

			Class<Job> jobClass, String jobGroup, HashMap<String, String> jobParams) throws ServiceException { 

		JobDetail jobDetail = new JobDetail(jobName, jobGroup, jobClass);

		switch (intervalChar) {

		case 's':

		case 'S':

			break;

		case 'm':

		case 'M':

			break;

		case 'h':

		case 'H':

			break;

		case 'd':

		case 'D':

			break;

		default:

			throw new ServiceException("SchedulerService.scheduleJob - Could not interpret interval unit: " 

	 * @param jobDetail

	 *            the job detail object

	 */

		Trigger trigger = TriggerUtils.makeSecondlyTrigger(interval);

		trigger.setName(jobName);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

	 * @param jobDetail

	 *            the job detail object

	 */

		Trigger trigger = TriggerUtils.makeMinutelyTrigger(interval);

		trigger.setName(jobName);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

	 * @param jobDetail

	 *            the job detail object

	 */

		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval);

		trigger.setName(jobName);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

	 * @param jobDetail

	 *            the job detail object

	 */

		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval * 24);

		trigger.setName(jobName);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

			}

			pstmt = conn.prepareStatement(sql);

			if (groupName != null) {

				pstmt.setString(1, groupName);

			}

			pstmt.execute();

	 *            a map of parameters that are associated with this job.

	 */

	public void createJob(String name, String triggerName, String groupName,

			String intervalUnit, HashMap<String, String> jobParams)

			throws AccessException {

		jobDAO.setGroupName(groupName);

		jobDAO.setClassName(jobClass.getName());

		jobDAO.setStartTime(new Timestamp(startTime.getTimeInMillis()));

		jobDAO.setIntervalValue(intervalValue);

		jobDAO.setIntervalUnit(intervalUnit);

		// First insert the job

		try {

			String sql = 

			pstmt = conn.prepareStatement(sql);

			pstmt.setString(1, jobDAO.getStatus());

			pstmt.setString(4, jobDAO.getGroupName());

			pstmt.setString(5, jobDAO.getClassName());

			pstmt.setTimestamp(6, jobDAO.getStartTime());

			pstmt.execute();

		} catch (SQLException sqle) {

			pstmt.setString(1, jobDAO.getStatus());

			pstmt.setLong(2, jobDAO.getId());

			pstmt.execute();

		} catch (SQLException sqle) {

		jobDAO.setGroupName(resultSet.getString("group_name"));

		jobDAO.setClassName(resultSet.getString("class_name"));

		jobDAO.setStartTime(resultSet.getTimestamp("start_time"));

		jobDAO.setIntervalValue(resultSet.getInt("interval_value"));

		jobDAO.setIntervalUnit(resultSet.getString("interval_unit"));