public void enableTools() {
List<Schedule> scheduleList = schedulesListCtrl.getSelectedSchedules();
boolean suspendEnabled = false, resumeEnabled = false;
boolean resolvedSuspended = false, resolvedEnabled = false;
for (Schedule schedule : scheduleList) {
if (!resolvedSuspended
&& !schedule.getTriggerState().equalsIgnoreCase(SUSPENDED_SCHEDULER_STATE)) {
suspendEnabled = true;
resolvedSuspended = true;
}
if (!resolvedEnabled
&& !schedule.getTriggerState().equalsIgnoreCase(NORMAL_SCHEDULER_STATE)) {
resumeEnabled = true;
resolvedEnabled = true;
}
}
int numSelectedItems = scheduleList.size();
enableWidget(schedulerToolbar.getCreateBtn(), true);
enableWidget(schedulerToolbar.getUpdateBtn(), 1 == numSelectedItems);
enableWidget(schedulerToolbar.getDeleteBtn(), numSelectedItems > 0);
enableWidget(schedulerToolbar.getSuspendBtn(), suspendEnabled);
enableWidget(schedulerToolbar.getResumeBtn(), resumeEnabled);
enableWidget(schedulerToolbar.getRunNowBtn(), numSelectedItems > 0);
enableWidget(schedulerToolbar.getRefreshBtn(), true);
}
private static List<Schedule> getSubscriptionSchedules(List<Schedule> schedList) {
List<Schedule> list = new ArrayList<Schedule>();
for (Schedule sched : schedList) {
if (sched.isSubscriptionSchedule()) {
list.add(sched);
}
}
return list;
}
private int getNumSubscribers() {
List<Schedule> schedList = schedulesListCtrl.getSelectedSchedules();
int numSubscribers = 0;
for (Schedule sched : schedList) {
try {
numSubscribers += Integer.parseInt(sched.getSubscriberCount());
} catch (NumberFormatException ex) {
// Do nothing, we'll return 0.
}
}
return numSubscribers;
}
private void handleUpdateSchedule() {
final SchedulerToolbarController localThis = this;
scheduleCreatorDialog.setTitle(Messages.getString("scheduleEditor")); // $NON-NLS-1$
final List<Schedule> scheduleList = schedulesListCtrl.getSelectedSchedules();
if (!loadingInitialized) {
scheduleCreatorDialog.setOkBtnEnabled(false);
}
scheduleCreatorDialog.setOnOkHandler(
new ICallback<MessageDialog>() {
public void onHandle(MessageDialog d) {
localThis.updateScheduleWithNewScheduleType();
}
});
this.scheduleCreatorDialog.setOnValidateHandler(
new IResponseCallback<MessageDialog, Boolean>() {
public Boolean onHandle(MessageDialog schedDlg) {
return isUpdateScheduleCreatorDialogValid();
}
});
// the update button should be enabled/disabled to guarantee that one and only one schedule is
// selected
assert scheduleList.size() == 1
: "When clicking update, exactly one schedule should be selected."; //$NON-NLS-1$
Schedule sched = scheduleList.get(0);
try {
initScheduleCreatorDialog(sched);
scheduleCreatorDialog.center();
scheduleCreatorDialog.getScheduleEditor().setFocus();
} catch (CronParseException e) {
final MessageDialog errorDialog =
new MessageDialog(
Messages.getString("error"), // $NON-NLS-1$
Messages.getString(
"invalidCronInInitOfRecurrenceDialog",
sched.getCronString(),
e.getMessage())); // $NON-NLS-1$
errorDialog.setOnOkHandler(
new ICallback<MessageDialog>() {
public void onHandle(MessageDialog messageDialog) {
errorDialog.hide();
scheduleCreatorDialog.center();
}
});
errorDialog.center();
}
}
private List<Schedule> getFilteredSchedulesList(List<Schedule> scheduleList) {
List<Schedule> filteredList = null;
String filterVal = schedulerToolbar.getFilterValue();
if (!SchedulerToolbar.ALL_GROUPS_FILTER.equals(filterVal)) {
filteredList = new ArrayList<Schedule>();
for (int ii = 0; ii < scheduleList.size(); ++ii) {
Schedule s = scheduleList.get(ii);
if (s.getJobGroup().equals(filterVal)) {
filteredList.add(s);
}
}
} else {
filteredList = scheduleList;
}
return filteredList;
}
@SuppressWarnings("fallthrough")
private void updateScheduleWithNewScheduleType() {
final List<Schedule> scheduleList = schedulesListCtrl.getSelectedSchedules();
Schedule oldSchedule = scheduleList.get(0);
AsyncCallback<Object> deleteScheduleCallback =
new AsyncCallback<Object>() {
public void onSuccess(Object o) {
createSchedule();
}
public void onFailure(Throwable caught) {
MessageDialogBox messageDialog =
new MessageDialogBox(
ExceptionParser.getErrorHeader(caught.getMessage()),
ExceptionParser.getErrorMessage(caught.getMessage(), caught.getMessage()),
false,
false,
true);
messageDialog.center();
}
};
// TODO sbarkdull scheduleCreatorDialog -> scheduleEditorDialog
DualModeScheduleEditor scheduleEditor = scheduleCreatorDialog.getScheduleEditor();
ISchedulerServiceAsync schedSvc = null;
if (oldSchedule.isSubscriptionSchedule() != scheduleEditor.isSubscriptionSchedule()) {
// they are changing the schedule type, so delete it, and add a new one
schedSvc =
oldSchedule.isSubscriptionSchedule()
? PacServiceFactory.getSubscriptionService()
: PacServiceFactory.getSchedulerService();
List<Schedule> deleteList = new ArrayList<Schedule>();
deleteList.add(oldSchedule);
schedSvc.deleteJobs(deleteList, deleteScheduleCallback);
} else {
// they are NOT changing the schedule type, so just update the existing schedule.
updateSchedule();
}
}
private void initFilterList() {
String currentFilter = schedulerToolbar.getFilterValue();
currentFilter = (null == currentFilter) ? SchedulerToolbar.ALL_GROUPS_FILTER : currentFilter;
Set<String> groupNames = new HashSet<String>();
List<Schedule> scheduleList = schedulesModel.getScheduleList();
for (int ii = 0; ii < scheduleList.size(); ++ii) {
Schedule s = scheduleList.get(ii);
String groupName = s.getJobGroup();
if (!groupNames.contains(groupName)) {
groupNames.add(groupName);
}
}
schedulerToolbar.clearFilters();
schedulerToolbar.addFilterItem(SchedulerToolbar.ALL_GROUPS_FILTER);
for (String name : groupNames) {
schedulerToolbar.addFilterItem(name);
}
schedulerToolbar.setFilterValue(currentFilter);
}
private void initSolutionRepositoryActionSequenceEditor(Schedule sched) {
solRepActionSequenceEditorController.init(sched.getActionsList());
}
private void initScheduleEditor(Schedule sched) throws CronParseException {
DualModeScheduleEditor scheduleEditor = scheduleCreatorDialog.getScheduleEditor();
scheduleEditor.setSubscriptionSchedule(sched.isSubscriptionSchedule());
scheduleEditor.setName(sched.getJobName());
scheduleEditor.setGroupName(sched.getJobGroup());
scheduleEditor.setDescription(sched.getDescription());
String repeatIntervalInMillisecs = sched.getRepeatInterval();
if (sched.isCronSchedule()) {
scheduleEditor.setCronString(sched.getCronString()); // throws CronParseException
} else if (sched.isRepeatSchedule()) {
long repeatIntervalInSecs =
TimeUtil.millsecondsToSecs(Long.parseLong(repeatIntervalInMillisecs));
if (0 == repeatIntervalInSecs) {
// run once
scheduleEditor.setScheduleType(ScheduleEditor.ScheduleType.RUN_ONCE);
} else {
// run multiple
scheduleEditor.setRepeatInSecs((int) repeatIntervalInSecs);
}
} else {
throw new RuntimeException(
Messages.getString("illegalStateMissingCronAndRepeat")); // $NON-NLS-1$
}
String timePart = null;
String strDate = sched.getStartDate();
if (null != strDate) {
Date startDate = TimeUtil.getDate(strDate);
if (sched.isRepeatSchedule()) {
timePart = TimeUtil.getTimePart(startDate);
scheduleEditor.setStartTime(timePart);
startDate = TimeUtil.zeroTimePart(startDate);
}
scheduleEditor.setStartDate(startDate);
}
// scheduleEditor.getRunOnceEditor().setStartTime(strTime)
// scheduleEditor.getRunOnceEditor().setStartDate(strTime)
strDate = sched.getEndDate();
if (null != strDate) {
scheduleEditor.setEndBy();
Date endDate = TimeUtil.getDate(strDate);
if (sched.isRepeatSchedule()) {
endDate = TimeUtil.zeroTimePart(endDate);
}
scheduleEditor.setEndDate(endDate);
} else {
scheduleEditor.setNoEndDate();
}
}
private void updateSchedule() {
AsyncCallback<Object> updateScheduleResponseCallback =
new AsyncCallback<Object>() {
public void onSuccess(Object o) {
scheduleCreatorDialog.hide();
loadJobsTable();
}
public void onFailure(Throwable caught) {
MessageDialogBox messageDialog =
new MessageDialogBox(
ExceptionParser.getErrorHeader(caught.getMessage()),
ExceptionParser.getErrorMessage(caught.getMessage(), caught.getMessage()),
false,
false,
true);
messageDialog.center();
}
};
final List<Schedule> scheduleList = schedulesListCtrl.getSelectedSchedules();
Schedule oldSchedule = scheduleList.get(0);
DualModeScheduleEditor scheduleEditor = scheduleCreatorDialog.getScheduleEditor();
ISchedulerServiceAsync schedSvc =
scheduleEditor.isSubscriptionSchedule()
? PacServiceFactory.getSubscriptionService()
: PacServiceFactory.getSchedulerService();
String cronStr = scheduleEditor.getCronString();
Date startDate = scheduleEditor.getStartDate();
Date endDate = scheduleEditor.getEndDate();
if (null == cronStr) { // must be a repeating schedule
String startTime =
scheduleEditor
.getStartTime(); // format of string should be: HH:MM:SS AM/PM, e.g. 7:12:28 PM
startDate = TimeUtil.getDateTime(startTime, startDate);
endDate = (null != endDate) ? TimeUtil.getDateTime(startTime, endDate) : null;
}
ScheduleEditor.ScheduleType rt = scheduleEditor.getScheduleType();
switch (rt) {
case RUN_ONCE:
schedSvc.updateRepeatSchedule(
oldSchedule.getJobName(),
oldSchedule.getJobGroup(),
oldSchedule.getSchedId(),
scheduleEditor.getName().trim(),
scheduleEditor.getGroupName().trim(),
scheduleEditor.getDescription().trim(),
startDate,
endDate,
"0" /*repeat count*/, //$NON-NLS-1$
"0" /*repeat time*/, //$NON-NLS-1$
scheduleCreatorDialog
.getSolutionRepositoryActionSequenceEditor()
.getActionsAsString()
.trim(),
updateScheduleResponseCallback);
break;
case SECONDS: // fall through
case MINUTES: // fall through
case HOURS: // fall through
case DAILY: // fall through
case WEEKLY: // fall through
case MONTHLY: // fall through
case YEARLY:
if (null == cronStr) {
String repeatInterval =
Long.toString(TimeUtil.secsToMillisecs(scheduleEditor.getRepeatInSecs()));
schedSvc.updateRepeatSchedule(
oldSchedule.getJobName(),
oldSchedule.getJobGroup(),
oldSchedule.getSchedId(),
scheduleEditor.getName().trim(),
scheduleEditor.getGroupName().trim(),
scheduleEditor.getDescription().trim(),
startDate,
endDate,
null /*repeat count*/,
repeatInterval.trim(),
scheduleCreatorDialog
.getSolutionRepositoryActionSequenceEditor()
.getActionsAsString()
.trim(),
updateScheduleResponseCallback);
break;
} else {
// fall through to case CRON
}
case CRON:
schedSvc.updateCronSchedule(
oldSchedule.getJobName(),
oldSchedule.getJobGroup(),
oldSchedule.getSchedId(),
scheduleEditor.getName().trim(),
scheduleEditor.getGroupName().trim(),
scheduleEditor.getDescription().trim(),
startDate,
endDate,
cronStr.trim(),
scheduleCreatorDialog
.getSolutionRepositoryActionSequenceEditor()
.getActionsAsString()
.trim(),
updateScheduleResponseCallback);
break;
default:
throw new RuntimeException(
Messages.getString("invalidRunType", rt.toString())); // $NON-NLS-1$
}
}