/**
* @param cronStr
* @throws CronParseException if cronStr is not a valid CRON string.
*/
public void setCronString(String cronStr) throws CronParseException {
// Try original simplistic parser...
CronParser cp = new CronParser(cronStr);
String recurrenceStr = null;
try {
recurrenceStr = cp.parseToRecurrenceString(); // throws CronParseException
} catch (CronParseException e) {
if (!CronExpression.isValidExpression(cronStr)) { // Parse with proper expression parser
throw e;
}
recurrenceStr = null; // valid cronstring, not parse-able to recurrence string
}
if (null != recurrenceStr) {
recurrenceEditor.inititalizeWithRecurrenceString(recurrenceStr);
TemporalValue tv = recurrenceEditor.getTemporalState();
ScheduleType rt = temporalValueToScheduleType(tv);
setScheduleType(rt);
} else {
// its a cron string that cannot be parsed into a recurrence string, switch to cron string
// editor.
setScheduleType(ScheduleType.CRON);
}
cronEditor.setCronString(cronStr);
}
public Date getStartDate() {
switch (getScheduleType()) {
case RUN_ONCE:
Date startDate = runOnceEditor.getStartDate();
String startTime = runOnceEditor.getStartTime();
String[] times = startTime.split(":"); // $NON-NLS-1$
int hour = Integer.parseInt(times[0]);
int minute = Integer.parseInt(times[1]);
if (startTime.indexOf("PM") >= 0) { // $NON-NLS-1$
hour += 12;
}
startDate.setHours(hour);
startDate.setMinutes(minute);
startDate.setSeconds(0);
return startDate;
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:
return recurrenceEditor.getStartDate();
case CRON:
return cronEditor.getStartDate();
default:
throw new RuntimeException(MSGS.invalidRunType(getScheduleType().toString()));
}
}
public void reset(Date now) {
runOnceEditor.reset(now);
recurrenceEditor.reset(now);
cronEditor.reset(now);
setScheduleType(ScheduleType.RUN_ONCE);
}
private void configureOnChangeHandler() {
final ScheduleEditor localThis = this;
ICallback<IChangeHandler> handler =
new ICallback<IChangeHandler>() {
@Override
public void onHandle(IChangeHandler o) {
localThis.changeHandler();
}
};
ChangeHandler changeHandler =
new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
localThis.changeHandler();
}
};
ClickHandler clickHandler =
new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
localThis.changeHandler();
}
};
scheduleCombo.addChangeHandler(changeHandler);
runOnceEditor.setOnChangeHandler(handler);
recurrenceEditor.setOnChangeHandler(handler);
cronEditor.setOnChangeHandler(handler);
if (daysListBox != null) {
this.daysListBox.addChangeHandler(changeHandler);
}
if (hoursListBox != null) {
this.hoursListBox.addChangeHandler(changeHandler);
}
if (minutesListBox != null) {
this.minutesListBox.addChangeHandler(changeHandler);
}
if (this.startTimePicker != null) {
startTimePicker.setOnChangeHandler(handler);
}
if (this.blockoutEndTimePicker != null) {
this.blockoutEndTimePicker.setOnChangeHandler(handler);
}
if (this.durationRadioButton != null) {
this.durationRadioButton.addClickHandler(clickHandler);
}
if (this.endTimeRadioButton != null) {
this.endTimeRadioButton.addClickHandler(clickHandler);
}
}
public Date getEndDate() {
switch (getScheduleType()) {
case RUN_ONCE:
return null;
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:
return recurrenceEditor.getEndDate();
case CRON:
return cronEditor.getEndDate();
default:
throw new RuntimeException(MSGS.invalidRunType(getScheduleType().toString()));
}
}
private void selectScheduleTypeEditor(ScheduleType scheduleType) {
// if we are switching to cron type, then hide the start time panel
if ((isBlockoutDialog == false) && (startTimePanel != null)) {
if (scheduleType == ScheduleType.CRON) {
startTimePanel.setVisible(false);
} else {
startTimePanel.setVisible(true);
}
}
// hide all panels
for (Map.Entry<ScheduleType, Panel> me : scheduleTypeMap.entrySet()) {
me.getValue().setVisible(false);
}
// show the selected panel
Panel p = scheduleTypeMap.get(scheduleType);
p.setVisible(true);
TemporalValue tv = scheduleTypeToTemporalValue(scheduleType);
if (null != tv) {
// force the recurrence editor to display the appropriate ui
recurrenceEditor.setTemporalState(tv);
}
}
public void setEndBy() {
cronEditor.setEndBy();
recurrenceEditor.setEndBy();
}
public void setNoEndDate() {
recurrenceEditor.setNoEndDate();
cronEditor.setNoEndDate();
}
public void setEndDate(Date endDate) {
recurrenceEditor.setEndDate(endDate);
cronEditor.setEndDate(endDate);
}
public void setStartDate(Date startDate) {
runOnceEditor.setStartDate(startDate);
recurrenceEditor.setStartDate(startDate);
cronEditor.setStartDate(startDate);
}
public void setStartTime(String startTime) {
runOnceEditor.setStartTime(startTime);
recurrenceEditor.setStartTime(startTime);
}
public void setRepeatInSecs(Integer repeatInSecs) {
recurrenceEditor.inititalizeWithRepeatInSecs(repeatInSecs);
TemporalValue tv = recurrenceEditor.getTemporalState();
ScheduleType rt = temporalValueToScheduleType(tv);
setScheduleType(rt);
}
/**
* @return null if the selected schedule does not support repeat-in-seconds, otherwise return the
* number of seconds between schedule execution.
* @throws RuntimeException if the temporal value is invalid. This condition occurs as a result of
* programmer error.
*/
public Long getRepeatInSecs() throws RuntimeException {
return recurrenceEditor.getRepeatInSecs();
}
public ScheduleEditor(ScheduleDialogType type) {
super();
isBlockoutDialog = (type == ScheduleDialogType.BLOCKOUT);
startTimePicker = new TimePicker();
setStylePrimaryName("scheduleEditor"); // $NON-NLS-1$
scheduleCombo = createScheduleCombo();
Label l = new Label(MSGS.recurrenceColon());
l.setStyleName(SCHEDULE_LABEL);
add(l);
add(scheduleCombo);
SimplePanel hspacer = new SimplePanel();
hspacer.setWidth("100px"); // $NON-NLS-1$
if (!isBlockoutDialog) {
startTimePanel = createStartTimePanel();
add(startTimePanel);
} else {
// Blockout End TimePicker
blockoutEndTimePicker = new TimePicker();
blockoutEndTimePicker.setHour("01"); // $NON-NLS-1$
blockoutEndTimePicker.setMinute("00"); // $NON-NLS-1$
blockoutEndTimePicker.setTimeOfDay(TimeUtil.TimeOfDay.PM);
// Blockout End Caption Panel
blockoutEndTimePicker.getElement().getStyle().setDisplay(Display.NONE);
final String[] daysList = new String[365];
final String[] hoursList = new String[24];
final String[] minutesList = new String[60];
// Populate list
for (Integer i = 0; i < 365; i++) {
String iStr = i.toString();
daysList[i] = iStr;
if (i < 60) {
minutesList[i] = iStr;
if (i < 24) {
hoursList[i] = iStr;
}
}
}
// Units of time Drop Down
daysListBox = new ListBox();
daysListBox.getElement().setId("daysListBox"); // $NON-NLS-1$
populateListItems(daysListBox, daysList, 0, 365);
final Label daysLabel = new Label(MSGS.dayOrDays());
daysLabel.getElement().setAttribute("for", daysListBox.getElement().getId()); // $NON-NLS-1$
hoursListBox = new ListBox();
hoursListBox.getElement().setId("hoursListBox"); // $NON-NLS-1$
populateListItems(hoursListBox, hoursList, 0, 24);
final Label hoursLabel = new Label(MSGS.hourOrHours());
hoursLabel.getElement().setAttribute("for", hoursListBox.getElement().getId()); // $NON-NLS-1$
minutesListBox = new ListBox();
minutesListBox.getElement().setId("minutesListBox"); // $NON-NLS-1$
populateListItems(minutesListBox, minutesList, 0, 60);
final Label minutesLabel = new Label(MSGS.minuteOrMinutes());
minutesLabel
.getElement()
.setAttribute("for", minutesListBox.getElement().getId()); // $NON-NLS-1$
final HorizontalPanel durationPanel = new HorizontalPanel();
durationPanel.setVerticalAlignment(VerticalPanel.ALIGN_MIDDLE);
durationPanel.setSpacing(blockoutEndTimePicker.getSpacing());
durationPanel.add(daysListBox);
durationPanel.add(daysLabel);
durationPanel.add(hoursListBox);
durationPanel.add(hoursLabel);
durationPanel.add(minutesListBox);
durationPanel.add(minutesLabel);
// Bind change handler
this.scheduleCombo.addChangeHandler(
new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
String scheduleType = scheduleCombo.getItemText(scheduleCombo.getSelectedIndex());
if (ScheduleType.RUN_ONCE.toString().equals(scheduleType)) {
show(
true,
daysListBox,
daysLabel,
hoursListBox,
hoursLabel,
minutesListBox,
minutesLabel);
populateListItems(daysListBox, daysList, 0, 365);
populateListItems(hoursListBox, hoursList, 0, 24);
populateListItems(minutesListBox, minutesList, 0, 60);
} else if (ScheduleType.HOURS.toString().equals(scheduleType)) {
hide(true, daysListBox, daysLabel, hoursListBox, hoursLabel);
show(true, minutesListBox, minutesLabel);
populateListItems(minutesListBox, minutesList, 0, 60);
} else if (ScheduleType.DAILY.toString().equals(scheduleType)) {
hide(true, daysListBox, daysLabel);
show(true, hoursListBox, hoursLabel, minutesListBox, minutesLabel);
populateListItems(hoursListBox, hoursList, 0, 24);
populateListItems(minutesListBox, minutesList, 0, 60);
} else if (ScheduleType.WEEKLY.toString().equals(scheduleType)) {
show(
true,
daysListBox,
daysLabel,
hoursListBox,
hoursLabel,
minutesListBox,
minutesLabel);
populateListItems(daysListBox, daysList, 0, 7);
populateListItems(hoursListBox, hoursList, 0, 24);
populateListItems(minutesListBox, minutesList, 0, 60);
} else if (ScheduleType.MONTHLY.toString().equals(scheduleType)) {
show(
true,
daysListBox,
daysLabel,
hoursListBox,
hoursLabel,
minutesListBox,
minutesLabel);
populateListItems(daysListBox, daysList, 0, 28);
populateListItems(hoursListBox, hoursList, 0, 24);
populateListItems(minutesListBox, minutesList, 0, 60);
} else if (ScheduleType.YEARLY.toString().equals(scheduleType)) {
show(
true,
daysListBox,
daysLabel,
hoursListBox,
hoursLabel,
minutesListBox,
minutesLabel);
populateListItems(daysListBox, daysList, 0, 365);
populateListItems(hoursListBox, hoursList, 0, 24);
populateListItems(minutesListBox, minutesList, 0, 60);
}
}
});
/*
* Radio Buttons for duration
*/
this.durationRadioButton =
new RadioButton("durationRadioGroup", "durationRadioButton"); // $NON-NLS-1$ //$NON-NLS-2$
this.durationRadioButton.setText(MSGS.duration());
this.durationRadioButton.setValue(Boolean.TRUE);
this.durationRadioButton.addClickHandler(
new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
blockoutEndTimePicker.getElement().getStyle().setDisplay(Display.NONE);
durationPanel.getElement().getStyle().clearDisplay();
}
});
this.endTimeRadioButton =
new RadioButton("durationRadioGroup", "endTimeRadioButton"); // $NON-NLS-1$ //$NON-NLS-2$
this.endTimeRadioButton.setText(MSGS.endTime());
this.endTimeRadioButton.addClickHandler(
new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
blockoutEndTimePicker.getElement().getStyle().clearDisplay();
durationPanel.getElement().getStyle().setDisplay(Display.NONE);
}
});
// Radio Buttons Panel
HorizontalPanel radioButtonsPanel = new HorizontalPanel();
radioButtonsPanel.setVerticalAlignment(VerticalPanel.ALIGN_MIDDLE);
radioButtonsPanel.add(this.durationRadioButton);
radioButtonsPanel.add(this.endTimeRadioButton);
// Ends Panel
VerticalPanel endsPanel = new VerticalPanel();
endsPanel.add(radioButtonsPanel);
endsPanel.add(blockoutEndTimePicker);
endsPanel.add(durationPanel);
// Blockout period
CaptionPanel blockoutStartCaptionPanel = new CaptionPanel(MSGS.startTime());
HorizontalPanel blockoutStartPanel = new HorizontalPanel();
blockoutStartPanel.add(getStartTimePicker());
timeZonePicker = new ListBox();
timeZonePicker.setStyleName("timeZonePicker");
timeZonePicker.setVisibleItemCount(1);
blockoutStartPanel.add(timeZonePicker);
timeZonePicker.getElement().getParentElement().getStyle().setPaddingTop(5, Unit.PX);
blockoutStartCaptionPanel.add(blockoutStartPanel);
populateTimeZonePicker();
// Ends Caption Panel
CaptionPanel endCaptionPanel = new CaptionPanel(MSGS.endsCaptionTitle());
endCaptionPanel.add(endsPanel);
VerticalPanel blockoutPanel = new VerticalPanel();
blockoutPanel.setWidth("100%"); // $NON-NLS-1$
blockoutPanel.add(blockoutStartCaptionPanel);
blockoutPanel.add(endCaptionPanel);
add(blockoutPanel);
}
VerticalPanel vp = new VerticalPanel();
vp.setWidth("100%"); // $NON-NLS-1$
add(vp);
setCellHeight(vp, "100%"); // $NON-NLS-1$
runOnceEditor = new RunOnceEditor(startTimePicker);
vp.add(runOnceEditor);
scheduleTypeMap.put(ScheduleType.RUN_ONCE, runOnceEditor);
runOnceEditor.setVisible(true);
recurrenceEditor = new RecurrenceEditor(startTimePicker);
vp.add(recurrenceEditor);
scheduleTypeMap.put(ScheduleType.SECONDS, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.MINUTES, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.HOURS, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.DAILY, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.WEEKLY, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.MONTHLY, recurrenceEditor);
scheduleTypeMap.put(ScheduleType.YEARLY, recurrenceEditor);
recurrenceEditor.setVisible(false);
cronEditor = new CronEditor();
scheduleTypeMap.put(ScheduleType.CRON, cronEditor);
cronEditor.setVisible(false);
if (!isBlockoutDialog) {
vp.add(cronEditor);
VerticalPanel blockoutButtonPanel = new VerticalPanel();
blockoutButtonPanel.setWidth("100%"); // $NON-NLS-1$
// blockoutButtonPanel.setHeight("30%");
blockoutButtonPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
blockoutButtonPanel.setVerticalAlignment(VerticalPanel.ALIGN_MIDDLE);
// We want to add a button to check for blockout conflicts
blockoutCheckButton.setStyleName("pentaho-button"); // $NON-NLS-1$
blockoutCheckButton.getElement().setId("blockout-check-button"); // $NON-NLS-1$
blockoutCheckButton.setVisible(false);
hspacer.setHeight("50px"); // $NON-NLS-1$
blockoutButtonPanel.add(hspacer);
blockoutButtonPanel.add(blockoutCheckButton);
vp.add(hspacer);
add(blockoutButtonPanel);
}
configureOnChangeHandler();
}