How to let the required attribute of h:inputText depend on certain set of values from h:selectOneMenu?

Question

I am using JSF 2.0.

I have a h:selectOneMenu on my page which contains a list of values and there is one h:inputText on the same page, whose required should depend on the currently selected value of the h:selectOneMenu. Only a certain set of values should trigger the required check, others not.

This is what I have tried:

<h:inputText ... required="#{(selectedPaymentType.value == 'some value') || (selectedPaymentType.value == 'other value')}" />

In the code above #{selectedPaymentType} is definied in h:selectOneMenu binding.

There are 3 more values like this which should trigger the required attribute to true. This looks kind of clumsy. Are there better ways to do so?

Answer 1

If it's possible within your design, you could use an enum as your PaymentType which include some Interface like

public interface RequireSomeMoreStuff {
   public boolean required();
}

public enum PaymentType implements RequireSomeMoreStuff {
   FOO { boolean required() { return true; } },
   BAR { boolean required() { return false; } }
}

Answer 2

Fant has given a hint in the right direction, that you should be using an enum which has a required property, but it seems that you're not entirely sure how to properly implement it. Admittedly, Fant's answer is not elaborate enough. So here's a more elaborate answer.

Basically, you need to replace all dropdown values by an enum which look like this:

public enum PaymentType {
    FOO("Some label for foo", true),
    BAR("Some label for bar", false),
    BAZ("Some label for baz", true);

    private String label;
    private boolean required;

    private PaymentType(String label, boolean required) {
        this.label = label; 
        this.required = required;
    }

    public String getLabel() { 
        return label;
    }

    public boolean isRequired() {
        return required;
    }
}

And use it as follows

<h:selectOneMenu binding="#{selectedPaymentType}" value="#{bean.selectedPaymentType}">
    <f:selectItems value="#{bean.availablePaymentTypes}" var="paymentType"
        itemValue="#{paymentType}" itemLabel="#{paymentType.label}" />
</h:selectOneMenu>
<h:inputText ... required="#{selectedPaymentType.value.required}" />

with

private PaymentType selectedPaymentType; // +getter+setter

public PaymentType[] getAvailablePaymentTypes() { 
    return PaymentType.values();
}

(or if you're using OmniFaces, use <o:importConstants>, then you don't need such a getter for the <f:selectItems>; no, you don't need a converter in any case, JSF/EL has already builtin conversion for enums)

See, the required attribute is now so much more simplified as it's already definied in the model associated with the selected value.

Answer 3

I would use a4j in order to render the inputText only if certain values of your selectOneMenu are selected:

<h:selectOneMenu value="#{MyBean.selectedValue}">
    <f:selectItems value="#{MyBean.listOfValues}" />
    <a4j:support event="onchange" reRender="requiredText" ajaxSingle="true"/>
</h:selectOneMenu>

<a4j:outputPanel id="requiredText">
    <h:inputText value="#{MyBean.inputValue}" rendered="#{(MyBean.selectedValue == value_1) || (MyBean.selectedValue == value_2) || ...}" />
</a4j:outputPanel>

In order to avoid a large string on inputText's rendered parameter, I suggest you to create a boolean function which performs these conditions: rendered="#{MyBean.inputTextIsRendered}.

CLIENT-SIDE SOLUTION

There's also a solution based on Validators. Here's my approach:

• JSF Code

The selectOneMenu code above uses the binding tag to bind the value selected in the selectOneMenu with an attribute that will be retrieved in the validator method, declared for the inputText component.

• Validator class

Then, you need to create the CheckInputValue validator class.

public class CheckInputValue implements Validator {
    public CheckInputValue() {}

    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {

        //We retrieve thei binded value:
        UIInput confirmComponent = (UIInput) component.getAttributes().get("selectedValue");
        String theValue = confirmComponent.getSubmittedValue();

        //Here you check the retrieved value with the list of values that makes your inputText required.
        //In these cases you will chech the inputText is not empty and, if so, you return a ValidatorException:
        if(isEmpty){
            FacesMessage message = new FacesMessage();
            message.setDetail("inputText cannot be empty");
            message.setSummary("inputText cannot be empty");
            message.setSeverity(FacesMessage.SEVERITY_ERROR);
            throw new ValidatorException(message);
        }
    }
}

• faces-config.xml

Finally, you have to declare your validator class in faces-config.xml:

<validator>
    <validator-id>CheckInputValue</validator-id>
    <validator-class>myPackage.myValidations.CheckInputValue</validator-class>
</validator>