PreferenceEntity.java

package org.jboss.seam.wiki.preferences.metamodel;

import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.hibernate.validator.NotNull;
import org.jboss.seam.core.Interpolator;
import org.jboss.seam.core.Validators;
import org.jboss.seam.log.Log;
import org.jboss.seam.log.Logging;
import org.jboss.seam.util.Reflections;
import org.jboss.seam.wiki.preferences.PreferenceValue;
import org.jboss.seam.wiki.preferences.PreferenceVisibility;
import org.jboss.seam.wiki.preferences.annotations.PreferenceProperty;
import org.jboss.seam.wiki.preferences.annotations.Preferences;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.*;

/*
TODO: This implementation of Comparable is not consistent with equals()!
 */
public class PreferenceEntity implements Comparable, Serializable {

    Log log = Logging.getLog(PreferenceEntity.class);

    private Class clazz;
    private String description;
    private String entityName;
    private String mappedTo;
    private SortedSet<Property> properties = new TreeSet<Property>();
    private Map<String, Property> propertiesByName = new HashMap<String,Property>();
    private SortedSet<Property> propertiesSystemVisible = new TreeSet<Property>();
    private SortedSet<Property> propertiesUserVisible = new TreeSet<Property>();
    private SortedSet<Property> propertiesInstanceVisible = new TreeSet<Property>();

    public PreferenceEntity(Class<?> entityClass) {
        if (!entityClass.isAnnotationPresent(Preferences.class)) {
            throw new RuntimeException("Configured as preferences but missing @Preferences: " + entityClass.getName());
        }

        this.clazz = entityClass;
        this.description = interpolate(entityClass.getAnnotation(Preferences.class).description());
        this.entityName = entityClass.getAnnotation(Preferences.class).name();
        this.mappedTo = entityClass.getAnnotation(Preferences.class).mappedTo();
        if (this.entityName != null && this.entityName.length() == 0) this.entityName = clazz.getSimpleName();

        // @PreferenceProperty fields
        for (Field field : entityClass.getDeclaredFields()) {
            if (field.isAnnotationPresent(PreferenceProperty.class)) {
                if (!field.isAccessible()) field.setAccessible(true);

                Property property =
                    new Property(field.getName(),
                                 field.getType(),
                                 interpolate(field.getAnnotation(PreferenceProperty.class).description()),
                                 field.getAnnotation(PreferenceProperty.class).visibility(),
                                 field.getAnnotation(PreferenceProperty.class).editorIncludeName(),
                                 field.getAnnotation(PreferenceProperty.class).templateComponentName(),
                                 field.getAnnotation(PreferenceProperty.class).mappedTo()
                    );

                if (property.isSystemVisible()) propertiesSystemVisible.add(property);
                if (property.isUserVisible()) propertiesUserVisible.add(property);
                if (property.isInstanceVisible()) propertiesInstanceVisible.add(property);
                properties.add(property);
                propertiesByName.put(property.getFieldName(), property);
            }
        }
    }

    public Class getClazz() {
        return clazz;
    }

    public String getDescription() {
        return description;
    }

    public String getEntityName() {
        return entityName;
    }

    public String getMappedTo() {
        return mappedTo;
    }

    public SortedSet<Property> getProperties() {
        return properties;
    }

    public Map<String, Property> getPropertiesByName() {
        return propertiesByName;
    }

    public SortedSet<Property> getPropertiesSystemVisible() {
        return propertiesSystemVisible;
    }

    public SortedSet<Property> getPropertiesUserVisible() {
        return propertiesUserVisible;
    }

    public SortedSet<Property> getPropertiesInstanceVisible() {
        return propertiesInstanceVisible;
    }

    public boolean isSystemPropertiesVisible() {
        return propertiesSystemVisible.size() != 0;
    }

    public boolean isUserPropertiesVisible() {
        return propertiesUserVisible.size() != 0;
    }

    public boolean isInstancePropertiesVisible() {
        return propertiesInstanceVisible.size() != 0;
    }

    public Object materialize(Set<PreferenceValue> valueHolders) {
        log.trace("materializing preference entity instance: " + getEntityName());
        Map<Property, InvalidValue[]> invalidProperties = validate(valueHolders);
        if (invalidProperties.size() > 0) {
            log.error("can't materialize preference entity: " + getEntityName());
            for (Map.Entry<Property, InvalidValue[]> invalidProperty : invalidProperties.entrySet()) {
                log.error("invalid value for : " + invalidProperty.getKey());
                for (InvalidValue invalidValue : invalidProperty.getValue()) {
                    log.error("validation error: " + invalidValue.getMessage());
                }
            }
            throw new RuntimeException("could not materialize preference entity '"
                                        + getEntityName() + "', check the log");
        }

        Object preferenceEntityInstance;
        try {
            preferenceEntityInstance = getClazz().newInstance();
            for (PreferenceValue valueHolder : valueHolders) {
                log.trace("writing preference value: " + valueHolder.getPreferenceProperty().getFieldName());
                valueHolder.getPreferenceProperty()
                            .write(preferenceEntityInstance, valueHolder.getValue());
            }
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        return preferenceEntityInstance;
    }

    public Map<Property, InvalidValue[]> validate(Collection<PreferenceValue> valueHolders) {
        return validate(valueHolders, Arrays.asList(PreferenceVisibility.values()));
    }

    public Map<Property, InvalidValue[]> validate(Collection<PreferenceValue> valueHolders, List<PreferenceVisibility> visibilities) {
        log.trace("validating preference entity values");

        Set<Property> uncheckedProperties = getProperties();

        Map<Property, InvalidValue[]> invalidProperties = new HashMap<Property, InvalidValue[]>();
        for (PreferenceValue valueHolder : valueHolders) {
            Property property = valueHolder.getPreferenceProperty();
            log.trace("validating " + property);
            uncheckedProperties.remove(property);
            InvalidValue[] invalidValues = property.validate(valueHolder.getValue());
            if (invalidValues.length > 0) invalidProperties.put(property, invalidValues);
        }

        log.trace("validating properties with no values, checking for @NotNull by given visibility");
        // Now validate all the properties for which we didn't have values, they need to be !@NotNull
        if (uncheckedProperties.size() > 0) {
            boolean uncheckedAreNullable = true;
            for (Property uncheckedProperty : uncheckedProperties) {
                if (uncheckedProperty.getVisibility().containsAll(visibilities) && !uncheckedProperty.isNullable()) {
                    log.error("missing value for @NotNull " + uncheckedProperty);
                    uncheckedAreNullable = false;
                }
            }
            if (!uncheckedAreNullable) {
                throw new IllegalStateException("missing values for validation of " + getEntityName() + ", check the log");
            }
        }

        return invalidProperties;
    }

    public int compareTo(Object o) {
        return getDescription().compareTo(((PreferenceEntity) o).getDescription());
    }

    public String toString() {
        return "PreferenceEntity: " + getClazz().getName() + " properties: " + getProperties().size();
    }

    /*
    TODO: This implementation of Comparable is not consistent with equals()!
     */
    public class Property implements Comparable, Serializable {

        private String fieldName;
        private Class fieldType;
        private String description;
        private List<PreferenceVisibility> visibility;
        private String editorIncludeName;
        private String templateComponentName;
        private String mappedTo;

        public Property(String fieldName, Class fieldType, String description,
                        PreferenceVisibility[] visibility,
                        String editorIncludeName, String templateComponentName, String mappedTo) {
            this.fieldName = fieldName;
            this.fieldType = fieldType;
            this.description = description;
            this.visibility = Arrays.asList(visibility);
            this.editorIncludeName = editorIncludeName;
            this.templateComponentName = templateComponentName;
            this.mappedTo = mappedTo;
        }

        public Field getField() {
            return Reflections.getField(getClazz(), fieldName);
        }

        public String getOwningEntityName() {
            return getEntityName();
        }

        public String getFieldName() {
            return fieldName;
        }

        public Class getFieldType() {
            return fieldType;
        }

        public String getDescription() {
            return description;
        }

        public List<PreferenceVisibility> getVisibility() {
            return visibility;
        }

        public String getEditorIncludeName() {
            return "editor" + editorIncludeName;
        }

        public String getTemplateComponentName() {
            return templateComponentName;
        }

        public String getMappedTo() {
            return mappedTo;
        }

        public boolean isSystemVisible() {
            return getVisibility().contains(PreferenceVisibility.SYSTEM);
        }

        public boolean isUserVisible() {
            return getVisibility().contains(PreferenceVisibility.USER);
        }

        public boolean isInstanceVisible() {
            return getVisibility().contains(PreferenceVisibility.INSTANCE);
        }

        public void write(Object preferenceEntityInstance, Object value) throws Exception {
            Field field = getField();
            field.setAccessible(true);
            Reflections.set(field, preferenceEntityInstance, value);
        }

        public boolean isNullable() {
            return !getField().isAnnotationPresent(NotNull.class);
        }

        public InvalidValue[] validate(Object value) {
            ClassValidator validator = Validators.instance().getValidator(getClazz());
            return validator.getPotentialInvalidValues(getFieldName(), value);
        }

        public int compareTo(Object o) {
            return getDescription().compareTo(((Property) o).getDescription());
        }

        public String toString() {
            return "Property: " + getFieldName() + " of type: " + getFieldType();
        }
    }

    private String interpolate(String s) {
        return Interpolator.instance().interpolate(s);
    }

}