/**
*
*/
package org.richfaces.component;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.faces.FacesException;
import javax.faces.application.Application;
import javax.faces.application.FacesMessage;
import javax.faces.component.EditableValueHolder;
import javax.faces.component.UIComponent;
import javax.faces.component.UIComponentBase;
import javax.faces.component.UIInput;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.ConverterException;
import javax.faces.el.EvaluationException;
import javax.faces.el.MethodBinding;
import javax.faces.el.ValueBinding;
import javax.faces.model.ArrayDataModel;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
import org.ajax4jsf.component.UIDataAdaptor;
import org.ajax4jsf.model.DataComponentState;
import org.ajax4jsf.model.RepeatState;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.iterators.EmptyIterator;
import org.apache.commons.collections.iterators.FilterIterator;
import org.richfaces.component.util.MessageUtil;
/**
* @author Nick Belaevski
* mailto:nbelaevski@exadel.com
* created 16.11.2007
* @since 3.2
*/
public abstract class UIOrderingBaseComponent extends UIDataAdaptor implements EditableValueHolder {
private boolean localValueSet;
private List validators = null;
private MethodBinding validator;
public static final Predicate isColumn = new Predicate() {
public boolean evaluate(Object input) {
return (input instanceof javax.faces.component.UIColumn || input instanceof Column) &&
((UIComponent) input).isRendered();
}
};
protected boolean isSuitableValue(Object value, Object restoredObject) {
if (value instanceof Object[]) {
Object[] objects = (Object[]) value;
for (int i = 0; i < objects.length; i++) {
Object object = objects[i];
if (object != null && object.equals(restoredObject)) {
return true;
}
}
return false;
} else {
if (value != null) {
return ((Collection) value).contains(restoredObject);
} else {
return false;
}
}
}
public abstract boolean isOrderControlsVisible();
public abstract void setOrderControlsVisible(boolean visible);
public abstract boolean isFastOrderControlsVisible();
public abstract void setFastOrderControlsVisible(boolean visible);
public Object saveState(FacesContext faces) {
Object[] state = new Object[4];
state[0] = super.saveState(faces);
state[1] = saveAttachedState(faces, validators);
state[2] = saveAttachedState(faces, validator);
state[3] = localValueSet ? Boolean.TRUE : Boolean.FALSE;
return state;
}
public void restoreState(FacesContext faces, Object object) {
Object[] state = (Object[]) object;
super.restoreState(faces, state[0]);
validators = (List) restoreAttachedState(faces, state[1]);
validator = (MethodBinding) restoreAttachedState(faces, state[2]);
localValueSet = ((Boolean) state[3]).booleanValue();
}
protected DataComponentState createComponentState() {
return new RepeatState();
}
public Iterator columns() {
return new FilterIterator(getChildren().iterator(), isColumn);
}
protected Iterator dataChildren() {
if (getChildCount() != 0) {
return columns();
} else {
return EmptyIterator.INSTANCE;
}
}
protected Iterator fixedChildren() {
Map facets = getFacets();
if (facets != null) {
return facets.values().iterator();
} else {
return EmptyIterator.INSTANCE;
}
}
//validators
public MethodBinding getValidator() {
return validator;
}
public void setValidator(MethodBinding validatorBinding) {
this.validator = validatorBinding;
}
public Validator[] getValidators() {
if (validators == null) {
return new Validator[0];
} else {
return (Validator[]) validators.toArray(new Validator[validators.size()]);
}
}
public void addValidator(Validator validator) {
if (validator == null) {
throw new NullPointerException();
}
if (validators == null) {
validators = new ArrayList();
}
validators.add(validator);
}
public void removeValidator(Validator validator) {
if (validators != null) {
validators.remove(validator);
}
}
//validators end
public boolean isLocalValueSet() {
return localValueSet;
}
public void setLocalValueSet(boolean localValueSet) {
this.localValueSet = localValueSet;
}
protected DataModel createDataModel(Object value) {
DataModel dataModel;
if (value == null) {
dataModel = new ListDataModel(Collections.EMPTY_LIST);
} else if (value instanceof List) {
dataModel = new ListDataModel((List) value);
} else if (Object[].class.isAssignableFrom(value.getClass())) {
dataModel = new ArrayDataModel((Object[]) value);
} else {
throw new IllegalArgumentException();
}
return dataModel;
}
/**
* @exception NullPointerException {@inheritDoc}
*/
public void decode(FacesContext context) {
if (context == null) {
throw new NullPointerException();
}
// Force validity back to "true"
setValid(true);
super.decode(context);
}
/**
* <p>Specialized decode behavior on top of that provided by the
* superclass. In addition to the standard
* <code>processDecodes</code> behavior inherited from {@link
* UIComponentBase}, calls <code>validate()</code> if the the
* <code>immediate</code> property is true; if the component is
* invalid afterwards or a <code>RuntimeException</code> is thrown,
* calls {@link FacesContext#renderResponse}. </p>
* @exception NullPointerException {@inheritDoc}
*/
public void processDecodes(FacesContext context) {
if (context == null) {
throw new NullPointerException();
}
// Skip processing if our rendered flag is false
if (!isRendered()) {
return;
}
super.processDecodes(context);
if (isImmediate()) {
executeValidate(context);
}
}
/**
* Executes validation logic.
*/
protected void executeValidate(FacesContext context) {
try {
validate(context);
} catch (RuntimeException e) {
context.renderResponse();
throw e;
}
if (!isValid()) {
context.renderResponse();
}
}
public abstract void validate(FacesContext context);
/**
* <p>In addition to the standard <code>processValidators</code> behavior
* inherited from {@link UIComponentBase}, calls <code>validate()</code>
* if the <code>immediate</code> property is false (which is the
* default); if the component is invalid afterwards, calls
* {@link FacesContext#renderResponse}.
* If a <code>RuntimeException</code> is thrown during
* validation processing, calls {@link FacesContext#renderResponse}
* and re-throw the exception.
* </p>
* @exception NullPointerException {@inheritDoc}
*/
public void processValidators(FacesContext context) {
if (context == null) {
throw new NullPointerException();
}
// Skip processing if our rendered flag is false
if (!isRendered()) {
return;
}
super.processValidators(context);
if (!isImmediate()) {
executeValidate(context);
}
}
/**
*
* <p>Set the "valid" property according to the below algorithm.</p>
*
* <ul>
*
* <li>If the <code>valid</code> property on this component is still
* <code>true</code>, and the <code>required</code> property is also
* true, ensure that the local value is not empty (where "empty" is
* defined as <code>null</code> or a zero-length String. If the local
* value is empty:
* <ul>
* <li>Enqueue an appropriate error message by calling the
* <code>addMessage()</code> method on the <code>FacesContext</code>
* instance for the current request.</li>
* <li>Set the <code>valid</code> property on this component to
* <code>false</code>.</li>
* </ul></li>
* <li>If the <code>valid</code> property on this component is still
* <code>true</code>, and the local value is not empty, call the
* <code>validate()</code> method of each {@link Validator}
* registered for this {@link UIInput}, followed by the method
* pointed at by the <code>validatorBinding</code> property (if any).
* If any of these validators or the method throws a
* {@link ValidatorException}, catch the exception, add
* its message (if any) to the {@link FacesContext}, and set
* the <code>valid</code> property of this component to false.</li>
*
* </ul>
*
*/
protected void validateValue(FacesContext context, Object newValue) {
validateListValue(context, newValue, isEmpty(newValue), isRequired());
}
protected void validateListValue(FacesContext context, Object newValue,
boolean isEmpty, boolean isRequired) {
// If our value is valid, enforce the required property if present
requiredValidation(context, newValue, isEmpty, isRequired);
// If our value is valid and not empty, call all validators
processingValidators(context, newValue, isEmpty);
}
protected void requiredValidation(FacesContext context, Object newValue, boolean isRequired, boolean isEmpty) {
if (isValid() && isRequired && isEmpty) {
FacesMessage message = MessageUtil.getMessage(context, UIInput.REQUIRED_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
setValid(false);
}
}
protected void processingValidators(FacesContext context, Object newValue, boolean isEmpty) {
if (isValid() && !isEmpty) {
Validator[] validators = getValidators();
for (int i = 0; i < validators.length; i++) {
Validator validator = (Validator) validators[i];
try {
validator.validate(context, this, newValue);
}
catch (ValidatorException ve) {
// If the validator throws an exception, we're
// invalid, and we need to add a message
setValid(false);
FacesMessage message = ve.getFacesMessage();
if (message != null) {
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
}
}
}
MethodBinding validator = getValidator();
if (validator != null) {
try {
validator.invoke(context,
new Object[] { context, this, newValue});
}
catch (EvaluationException ee) {
if (ee.getCause() instanceof ValidatorException) {
ValidatorException ve =
(ValidatorException) ee.getCause();
// If the validator throws an exception, we're
// invalid, and we need to add a message
setValid(false);
FacesMessage message = ve.getFacesMessage();
if (message != null) {
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
}
} else {
// Otherwise, rethrow the EvaluationException
throw ee;
}
}
}
}
}
/**
* <p>In addition to the standard <code>processUpdates</code> behavior
* inherited from {@link UIComponentBase}, calls
* <code>updateModel()</code>.
* If the component is invalid afterwards, calls
* {@link FacesContext#renderResponse}.
* If a <code>RuntimeException</code> is thrown during
* update processing, calls {@link FacesContext#renderResponse}
* and re-throw the exception.
* </p>
* @exception NullPointerException {@inheritDoc}
*/
public void processUpdates(FacesContext context) {
if (context == null) {
throw new NullPointerException();
}
// Skip processing if our rendered flag is false
if (!isRendered()) {
return;
}
super.processUpdates(context);
try {
updateModel(context);
} catch (RuntimeException e) {
context.renderResponse();
throw e;
}
if (!isValid()) {
context.renderResponse();
}
}
public abstract void updateModel(FacesContext context);
protected interface UpdateModelCommand {
public void execute(FacesContext context);
}
protected interface DataAdder {
Object getContainer();
void add(Object object);
}
protected void updateModel(FacesContext context, UpdateModelCommand command) {
try {
command.execute(context);
} catch (EvaluationException e) {
String messageStr = e.getMessage();
FacesMessage message = null;
if (null == messageStr) {
message =
MessageUtil.getMessage(context, UIInput.UPDATE_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
}
else {
message = new FacesMessage(messageStr);
}
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
setValid(false);
}
catch (FacesException e) {
FacesMessage message =
MessageUtil.getMessage(context, UIInput.UPDATE_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
setValid(false);
} catch (IllegalArgumentException e) {
FacesMessage message =
MessageUtil.getMessage(context, UIInput.UPDATE_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
setValid(false);
} catch (Exception e) {
FacesMessage message =
MessageUtil.getMessage(context, UIInput.UPDATE_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
setValid(false);
}
}
/**
* <p>Return <code>true</code> if the new value is different from the
* previous value.</p>
*
* @param previous old value of this component (if any)
* @param value new value of this component (if any)
*/
protected boolean compareValues(Object previous, Object value) {
if (previous == null) {
return (value != null);
} else if (value == null) {
return (true);
} else {
if (previous instanceof Object[]) {
return !Arrays.equals((Object[]) previous, (Object[]) value);
} else {
return (!(previous.equals(value)));
}
}
}
protected void addConversionErrorMessage(FacesContext context,
ConverterException ce, Object value) {
FacesMessage message = ce.getFacesMessage();
if (message == null) {
message = MessageUtil.getMessage(context, UIInput.CONVERSION_MESSAGE_ID,
new Object[] {MessageUtil.getLabel(context, this)});
if (message.getDetail() == null) {
message.setDetail(ce.getMessage());
}
}
message.setSeverity(FacesMessage.SEVERITY_ERROR);
context.addMessage(getClientId(context), message);
}
protected boolean isEmpty(Object value) {
if (value == null) {
return (true);
} else if ((value instanceof String) &&
(((String) value).length() < 1)) {
return (true);
} else if (value.getClass().isArray()) {
if (0 == java.lang.reflect.Array.getLength(value)) {
return (true);
}
}
else if (value instanceof List) {
if (0 == ((List) value).size()) {
return (true);
}
}
return (false);
}
protected Object createContainer(ArrayList data, Object object) {
if (object != null) {
Class objectClass = object.getClass();
Class componentType = objectClass.getComponentType();
if (componentType != null) {
return data.toArray((Object[]) Array.newInstance(componentType, data.size()));
}
}
data.trimToSize();
return data;
}
public abstract ItemState getItemState();
public interface ItemState {
public boolean isSelected();
public boolean isActive();
}
private Converter getConverterForType(FacesContext context, Class type) {
if (!Object.class.equals(type)) {
Application application = context.getApplication();
return application.createConverter(type);
}
return null;
}
public Converter getConverterForValue(FacesContext context) {
ValueBinding binding = this.getValueBinding("value");
if (binding != null) {
Class type = binding.getType(context);
if (type != null) {
Class componentType = type.getComponentType();
if (componentType != null) {
return getConverterForType(context, componentType);
} else {
//support for generics introspection
}
}
}
return null;
}
}