modules/enterprise/gui/coregui/src/main/java/org/rhq/enterprise/gui/coregui/client/alert/definitions/DampeningAlertDefinitionForm.java | 487 +++++++++- 1 file changed, 480 insertions(+), 7 deletions(-)
New commits: commit 88e3f764331265d6557274f8b8443a7b75ea76de Author: John Mazzitelli mazz@redhat.com Date: Wed Sep 22 17:39:25 2010 -0400
initial try of the dampening editor. still some work to make it prettier, but its functional. let's you view and edit/save dampening rules
diff --git a/modules/enterprise/gui/coregui/src/main/java/org/rhq/enterprise/gui/coregui/client/alert/definitions/DampeningAlertDefinitionForm.java b/modules/enterprise/gui/coregui/src/main/java/org/rhq/enterprise/gui/coregui/client/alert/definitions/DampeningAlertDefinitionForm.java index b332c3a..87eecea 100644 --- a/modules/enterprise/gui/coregui/src/main/java/org/rhq/enterprise/gui/coregui/client/alert/definitions/DampeningAlertDefinitionForm.java +++ b/modules/enterprise/gui/coregui/src/main/java/org/rhq/enterprise/gui/coregui/client/alert/definitions/DampeningAlertDefinitionForm.java @@ -23,7 +23,18 @@
package org.rhq.enterprise.gui.coregui.client.alert.definitions;
+import java.util.LinkedHashMap; + +import com.smartgwt.client.widgets.form.fields.SelectItem; +import com.smartgwt.client.widgets.form.fields.SpinnerItem; +import com.smartgwt.client.widgets.form.fields.StaticTextItem; +import com.smartgwt.client.widgets.form.fields.events.ChangedEvent; +import com.smartgwt.client.widgets.form.fields.events.ChangedHandler; + +import org.rhq.core.domain.alert.AlertDampening; import org.rhq.core.domain.alert.AlertDefinition; +import org.rhq.core.domain.alert.AlertDampening.Category; +import org.rhq.core.domain.alert.AlertDampening.TimeUnits; import org.rhq.enterprise.gui.coregui.client.util.selenium.LocatableDynamicForm;
/** @@ -35,6 +46,27 @@ public class DampeningAlertDefinitionForm extends LocatableDynamicForm implement
private boolean formBuilt = false;
+ private SelectItem dampeningRuleSelection; + private StaticTextItem dampeningRuleStatic; + + private SpinnerItem consecutiveOccurrencesSpinner; + private StaticTextItem consecutiveOccurrencesStatic; + + private SpinnerItem partialOccurrencesSpinner; + private StaticTextItem partialOccurrencesStatic; + + private SpinnerItem partialEvaluationsSpinner; + private StaticTextItem partialEvaluationsStatic; + + private SpinnerItem durationOccurrencesSpinner; + private StaticTextItem durationOccurrencesStatic; + + private SpinnerItem durationTimePeriodSpinner; + private StaticTextItem durationTimePeriodStatic; + + private SelectItem durationTimeUnitsSelection; + private StaticTextItem durationTimeUnitsStatic; + public DampeningAlertDefinitionForm(String locatorId) { this(locatorId, null); } @@ -69,7 +101,50 @@ public class DampeningAlertDefinitionForm extends LocatableDynamicForm implement if (alertDef == null) { clearFormValues(); } else { - // TODO set values of the components + clearFormValues(); + + AlertDampening alertDampening = alertDef.getAlertDampening(); + if (alertDampening == null) { + alertDampening = new AlertDampening(AlertDampening.Category.NONE); + alertDefinition.setAlertDampening(alertDampening); + } + + dampeningRuleSelection.setValue(alertDampening.getCategory().name()); + dampeningRuleStatic.setValue(getCategoryTitle(alertDampening.getCategory())); + + switch (alertDampening.getCategory()) { + case NONE: { + break; + } + case CONSECUTIVE_COUNT: { + consecutiveOccurrencesSpinner.setValue(alertDampening.getValue()); + consecutiveOccurrencesStatic.setValue(alertDampening.getValue()); + break; + } + case PARTIAL_COUNT: { + partialOccurrencesSpinner.setValue(alertDampening.getValue()); + partialOccurrencesStatic.setValue(alertDampening.getValue()); + + partialEvaluationsSpinner.setValue(alertDampening.getPeriod()); + partialEvaluationsStatic.setValue(alertDampening.getPeriod()); + break; + } + case DURATION_COUNT: { + durationOccurrencesSpinner.setValue(alertDampening.getValue()); + durationOccurrencesStatic.setValue(alertDampening.getValue()); + + durationTimePeriodSpinner.setValue(alertDampening.getPeriod()); + durationTimePeriodStatic.setValue(alertDampening.getPeriod()); + + durationTimeUnitsSelection.setValue(alertDampening.getPeriodUnits().name()); + durationTimeUnitsStatic.setValue(getTimeUnitsTitle(alertDampening.getPeriodUnits())); + break; + } + default: { + throw new IllegalStateException("Invalid category - please report this as a bug: " + + alertDampening.getCategory()); // should never happen + } + } }
markForRedraw(); @@ -77,36 +152,434 @@ public class DampeningAlertDefinitionForm extends LocatableDynamicForm implement
@Override public void makeEditable() { - // TODO Auto-generated method stub + dampeningRuleSelection.show(); + dampeningRuleStatic.hide(); + + AlertDampening.Category cat = AlertDampening.Category.valueOf(dampeningRuleSelection.getValue().toString()); + switch (cat) { + case NONE: { + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + break; + } + case CONSECUTIVE_COUNT: { + consecutiveOccurrencesSpinner.show(); + consecutiveOccurrencesStatic.hide(); + + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + + break; + } + case PARTIAL_COUNT: { + partialOccurrencesSpinner.show(); + partialOccurrencesStatic.hide(); + + partialEvaluationsSpinner.show(); + partialEvaluationsStatic.hide(); + + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + break; + } + case DURATION_COUNT: { + durationOccurrencesSpinner.show(); + durationOccurrencesStatic.hide(); + + durationTimePeriodSpinner.show(); + durationTimePeriodStatic.hide(); + + durationTimeUnitsSelection.show(); + durationTimeUnitsStatic.hide(); + + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + break; + } + default: { + throw new IllegalStateException("Bad dampening category - please report this bug: " + cat); // should never happen + } + }
markForRedraw(); }
@Override public void makeViewOnly() { - // TODO Auto-generated method stub + dampeningRuleSelection.hide(); + dampeningRuleStatic.show(); + + AlertDampening.Category cat = AlertDampening.Category.valueOf(dampeningRuleSelection.getValue().toString()); + switch (cat) { + case NONE: { + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + break; + } + case CONSECUTIVE_COUNT: { + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.show(); + + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + break; + } + case PARTIAL_COUNT: { + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.show(); + + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.show(); + + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.hide(); + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.hide(); + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.hide(); + break; + } + case DURATION_COUNT: { + durationOccurrencesSpinner.hide(); + durationOccurrencesStatic.show(); + + durationTimePeriodSpinner.hide(); + durationTimePeriodStatic.show(); + + durationTimeUnitsSelection.hide(); + durationTimeUnitsStatic.show(); + + consecutiveOccurrencesSpinner.hide(); + consecutiveOccurrencesStatic.hide(); + partialOccurrencesSpinner.hide(); + partialOccurrencesStatic.hide(); + partialEvaluationsSpinner.hide(); + partialEvaluationsStatic.hide(); + break; + } + default: { + throw new IllegalStateException("Bad dampening category - please report this bug: " + cat); // should never happen + } + }
markForRedraw(); }
@Override public void saveAlertDefinition() { - // TODO Auto-generated method stub + AlertDampening.Category cat = AlertDampening.Category.valueOf(dampeningRuleSelection.getValue().toString()); + AlertDampening alertDampening = new AlertDampening(cat); + switch (cat) { + case NONE: { + // each time condition set is true + alertDampening.setValue(0); + alertDampening.setValueUnits(null); + alertDampening.setPeriod(0); + alertDampening.setPeriodUnits(null); + break; + } + case CONSECUTIVE_COUNT: { + // once every N times condition set is true consecutively + alertDampening.setValue(Integer.valueOf(consecutiveOccurrencesSpinner.getValue().toString())); + alertDampening.setValueUnits(null); + alertDampening.setPeriod(0); + alertDampening.setPeriodUnits(null); + break; + } + case PARTIAL_COUNT: { + // once every N times condition set is true during the last M evaluations + alertDampening.setValue(Integer.valueOf(partialOccurrencesSpinner.getValue().toString())); + alertDampening.setValueUnits(null); + alertDampening.setPeriod(Integer.valueOf(partialEvaluationsSpinner.getValue().toString())); + alertDampening.setPeriodUnits(null); + break; + } + case DURATION_COUNT: { + // once every N times condition set is true within a time period of M {mins, hours, days, weeks} + alertDampening.setValue(Integer.valueOf(durationOccurrencesSpinner.getValue().toString())); + alertDampening.setValueUnits(null); + alertDampening.setPeriod(Integer.valueOf(durationTimePeriodSpinner.getValue().toString())); + alertDampening.setPeriodUnits(TimeUnits.valueOf(durationTimeUnitsSelection.getValue().toString())); + break; + } + default: { + throw new IllegalStateException("Bad dampening category - please report this bug: " + cat); // should never happen + } + } + alertDefinition.setAlertDampening(alertDampening); }
@Override public void clearFormValues() { - // TODO component.clearValue(); + dampeningRuleSelection.clearValue(); + consecutiveOccurrencesSpinner.clearValue(); + partialOccurrencesSpinner.clearValue(); + partialEvaluationsSpinner.clearValue(); + durationOccurrencesSpinner.clearValue(); + durationTimePeriodSpinner.clearValue(); + durationTimeUnitsSelection.clearValue(); + + dampeningRuleStatic.clearValue(); + consecutiveOccurrencesStatic.clearValue(); + partialOccurrencesStatic.clearValue(); + partialEvaluationsStatic.clearValue(); + durationOccurrencesStatic.clearValue(); + durationTimePeriodStatic.clearValue(); + durationTimeUnitsStatic.clearValue();
markForRedraw(); }
private void buildForm() { if (!formBuilt) { - // TODO buildNodes components - // TODO setFields(components); + setNumCols(3); + + dampeningRuleSelection = new SelectItem("dampeningRule", "Dampening Rule"); + LinkedHashMap<String, String> rules = new LinkedHashMap<String, String>(4); + rules.put(AlertDampening.Category.NONE.name(), getCategoryTitle(AlertDampening.Category.NONE)); + rules.put(AlertDampening.Category.CONSECUTIVE_COUNT.name(), + getCategoryTitle(AlertDampening.Category.CONSECUTIVE_COUNT)); + rules.put(AlertDampening.Category.PARTIAL_COUNT.name(), + getCategoryTitle(AlertDampening.Category.PARTIAL_COUNT)); + rules.put(AlertDampening.Category.DURATION_COUNT.name(), + getCategoryTitle(AlertDampening.Category.DURATION_COUNT)); + dampeningRuleSelection.setValueMap(rules); + dampeningRuleSelection.setDefaultValue(AlertDampening.Category.NONE.name()); + dampeningRuleSelection.setWrapTitle(false); + dampeningRuleSelection.setRedrawOnChange(true); + dampeningRuleSelection.setColSpan(2); + dampeningRuleStatic = new StaticTextItem("dampeningRuleStatic", "Dampening Rule"); + dampeningRuleStatic.setColSpan(2); + dampeningRuleStatic.setWrapTitle(false); + + // NONE + // nothing to do - the none category has no ui components to render + + // CONSECUTIVE_COUNT + consecutiveOccurrencesSpinner = new SpinnerItem("consecutiveOccurrencesSpinner", "Occurrences"); + consecutiveOccurrencesSpinner.setColSpan(2); + consecutiveOccurrencesSpinner.setWrapTitle(false); + consecutiveOccurrencesSpinner.setMin(1); + consecutiveOccurrencesSpinner.setMax(999999); + consecutiveOccurrencesSpinner.setStep(1); + consecutiveOccurrencesSpinner.setDefaultValue(1); + consecutiveOccurrencesSpinner + .setTooltip("The number of times the condition set must be consecutively true before the alert is triggered."); + consecutiveOccurrencesStatic = new StaticTextItem("consecutiveOccurrencesStatic", "Occurrences"); + consecutiveOccurrencesStatic.setColSpan(2); + consecutiveOccurrencesStatic.setWrapTitle(false); + + // PARTIAL_COUNT + partialOccurrencesSpinner = new SpinnerItem("partialOccurrencesSpinner", "Occurrences"); + partialOccurrencesSpinner.setColSpan(2); + partialOccurrencesSpinner.setWrapTitle(false); + partialOccurrencesSpinner.setMin(1); + partialOccurrencesSpinner.setMax(999999); + partialOccurrencesSpinner.setStep(1); + partialOccurrencesSpinner.setDefaultValue(1); + partialOccurrencesSpinner + .setTooltip("The number of times the condition set must be true during the last N evaluations before the alert is triggered."); + partialOccurrencesStatic = new StaticTextItem("partialOccurrencesStatic", "Occurrences"); + partialOccurrencesStatic.setColSpan(2); + partialOccurrencesStatic.setWrapTitle(false); + + partialEvaluationsSpinner = new SpinnerItem("partialEvaluationsSpinner", "Evaluations"); + partialEvaluationsSpinner.setColSpan(2); + partialEvaluationsSpinner.setWrapTitle(false); + partialEvaluationsSpinner.setMin(1); + partialEvaluationsSpinner.setMax(999999); + partialEvaluationsSpinner.setStep(1); + partialEvaluationsSpinner.setDefaultValue(1); + partialEvaluationsStatic = new StaticTextItem("partialEvaluationStatic", "Evaluations"); + partialEvaluationsStatic.setColSpan(2); + partialEvaluationsStatic.setWrapTitle(false); + + // DURATION_COUNT + durationOccurrencesSpinner = new SpinnerItem("durationOccurrencesSpinner", "Occurrences"); + durationOccurrencesSpinner.setColSpan(2); + durationOccurrencesSpinner.setWrapTitle(false); + durationOccurrencesSpinner.setMin(1); + durationOccurrencesSpinner.setMax(999999); + durationOccurrencesSpinner.setStep(1); + durationOccurrencesSpinner.setDefaultValue(1); + durationOccurrencesSpinner + .setTooltip("The number of times the condition set must be true during the given time period before the alert is triggered."); + durationOccurrencesStatic = new StaticTextItem("durationOccurrencesStatic", "Occurrences"); + durationOccurrencesStatic.setColSpan(2); + durationOccurrencesStatic.setWrapTitle(false); + + durationTimePeriodSpinner = new SpinnerItem("durationTimePeriodSpinner", "Time Period"); + durationTimePeriodSpinner.setEndRow(false); + durationTimePeriodSpinner.setWrapTitle(false); + durationTimePeriodSpinner.setMin(1); + durationTimePeriodSpinner.setMax(999999); + durationTimePeriodSpinner.setStep(1); + durationTimePeriodSpinner.setDefaultValue(1); + durationTimePeriodStatic = new StaticTextItem("durationTimePeriodStatic", "Time Period"); + durationTimePeriodStatic.setEndRow(false); + durationTimePeriodStatic.setWrapTitle(false); + + durationTimeUnitsSelection = new SelectItem("durationTimeUnits"); + LinkedHashMap<String, String> units = new LinkedHashMap<String, String>(4); + units.put(AlertDampening.TimeUnits.MINUTES.name(), getTimeUnitsTitle(AlertDampening.TimeUnits.MINUTES)); + units.put(AlertDampening.TimeUnits.HOURS.name(), getTimeUnitsTitle(AlertDampening.TimeUnits.HOURS)); + units.put(AlertDampening.TimeUnits.DAYS.name(), getTimeUnitsTitle(AlertDampening.TimeUnits.DAYS)); + units.put(AlertDampening.TimeUnits.WEEKS.name(), getTimeUnitsTitle(AlertDampening.TimeUnits.WEEKS)); + durationTimeUnitsSelection.setValueMap(units); + durationTimeUnitsSelection.setDefaultValue(AlertDampening.TimeUnits.MINUTES.name()); + durationTimeUnitsSelection.setStartRow(false); + durationTimeUnitsSelection.setEndRow(true); + durationTimeUnitsSelection.setShowTitle(false); + durationTimeUnitsStatic = new StaticTextItem("durationTimeUnitsStatic"); + durationTimeUnitsStatic.setStartRow(false); + durationTimeUnitsStatic.setEndRow(true); + durationTimeUnitsStatic.setShowTitle(false); + + dampeningRuleSelection.addChangedHandler(new ChangedHandler() { + @Override + public void onChanged(ChangedEvent event) { + Category cat = AlertDampening.Category.valueOf(event.getValue().toString()); + switch (cat) { + case NONE: { + consecutiveOccurrencesSpinner.hide(); + partialOccurrencesSpinner.hide(); + partialEvaluationsSpinner.hide(); + durationOccurrencesSpinner.hide(); + durationTimePeriodSpinner.hide(); + durationTimeUnitsSelection.hide(); + break; + } + case CONSECUTIVE_COUNT: { + consecutiveOccurrencesSpinner.show(); + partialOccurrencesSpinner.hide(); + partialEvaluationsSpinner.hide(); + durationOccurrencesSpinner.hide(); + durationTimePeriodSpinner.hide(); + durationTimeUnitsSelection.hide(); + break; + } + case PARTIAL_COUNT: { + consecutiveOccurrencesSpinner.hide(); + partialOccurrencesSpinner.show(); + partialEvaluationsSpinner.show(); + durationOccurrencesSpinner.hide(); + durationTimePeriodSpinner.hide(); + durationTimeUnitsSelection.hide(); + break; + } + case DURATION_COUNT: { + consecutiveOccurrencesSpinner.hide(); + partialOccurrencesSpinner.hide(); + partialEvaluationsSpinner.hide(); + durationOccurrencesSpinner.show(); + durationTimePeriodSpinner.show(); + durationTimeUnitsSelection.show(); + break; + } + default: { + throw new IllegalStateException("Invalid category - please report this as a bug: " + cat); // should never happen + } + } + markForRedraw(); + } + }); + + // put all the fields in the form now + setFields(dampeningRuleSelection, dampeningRuleStatic, consecutiveOccurrencesSpinner, + consecutiveOccurrencesStatic, partialOccurrencesSpinner, partialOccurrencesStatic, + partialEvaluationsSpinner, partialEvaluationsStatic, durationOccurrencesSpinner, + durationOccurrencesStatic, durationTimePeriodSpinner, durationTimePeriodStatic, + durationTimeUnitsSelection, durationTimeUnitsStatic);
formBuilt = true; } } + + private String getCategoryTitle(AlertDampening.Category category) { + switch (category) { + case NONE: { + return "None"; + } + case CONSECUTIVE_COUNT: { + return "Consecutive"; + } + case PARTIAL_COUNT: { + return "Last N Evaluations"; + } + case DURATION_COUNT: { + return "Time Period"; + } + default: { + throw new IllegalStateException("Invalid category - please report this as a bug: " + category); // should never happen + } + } + } + + private String getTimeUnitsTitle(AlertDampening.TimeUnits units) { + switch (units) { + case MINUTES: { + return "minutes"; + } + case HOURS: { + return "hours"; + } + case DAYS: { + return "days"; + } + case WEEKS: { + return "weeks"; + } + default: { + throw new IllegalStateException("Invalid time units - please report this as a bug: " + units); // should never happen + } + } + } }
rhq-commits@lists.fedorahosted.org