BasePolicyAnnotationTransformer.java

package com.thinkbiganalytics.policy;

/*-
 * #%L
 * thinkbig-field-policy-common
 * %%
 * Copyright (C) 2017 ThinkBig Analytics
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.thinkbiganalytics.annotations.AnnotatedFieldProperty;
import com.thinkbiganalytics.annotations.AnnotationFieldNameResolver;
import com.thinkbiganalytics.policy.rest.model.BaseUiPolicyRule;
import com.thinkbiganalytics.policy.rest.model.FieldRuleProperty;
import com.thinkbiganalytics.policy.rest.model.FieldRulePropertyBuilder;
import com.thinkbiganalytics.rest.model.LabelValue;

import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.lang3.reflect.ConstructorUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.commons.lang3.reflect.MethodUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * Transform classes annotated with a class annotation and fields with {@link PolicyProperty} to user interface {@link BaseUiPolicyRule} objects for input display in the browser and back.
 */
public abstract class BasePolicyAnnotationTransformer<U extends BaseUiPolicyRule, P extends Object, A extends Annotation>
    implements PolicyTransformer<U, P, A> {

    private static final Logger log = LoggerFactory.getLogger(BasePolicyAnnotationTransformer.class);

    /**
     * For a given domain policy class extract the user interface {@link FieldRuleProperty} classes parsing the fields annotated with the {@link PolicyProperty}
     *
     * @param policy the domain policy object to parse
     * @return a list of user interface fields annotated with the {@link PolicyProperty}
     */
    private List<FieldRuleProperty> getUiProperties(P policy) {
        AnnotationFieldNameResolver annotationFieldNameResolver = new AnnotationFieldNameResolver(PolicyProperty.class);
        List<AnnotatedFieldProperty> list = annotationFieldNameResolver.getProperties(policy.getClass());
        List<FieldRuleProperty> properties = new ArrayList<>();
        Map<String, Integer> groupOrder = new HashMap<>();
        Map<String, List<FieldRuleProperty>> groupedProperties = new HashMap<>();
        if (hasConstructor(policy.getClass())) {

            for (AnnotatedFieldProperty<PolicyProperty> annotatedFieldProperty : list) {
                PolicyProperty prop = annotatedFieldProperty.getAnnotation();
                String value = null;
                try {
                    Object fieldValue = FieldUtils.readField(annotatedFieldProperty.getField(), policy, true);
                    if (fieldValue != null) {
                        value = fieldValue.toString();
                    }
                } catch (IllegalAccessException e) {

                }
                String group = prop.group();
                Integer order = 0;
                if (!groupOrder.containsKey(group)) {
                    groupOrder.put(group, order);
                }
                order = groupOrder.get(group);
                order++;
                groupOrder.put(group, order);
                FieldRuleProperty rule = new FieldRulePropertyBuilder(prop.name()).displayName(
                    StringUtils.isNotBlank(prop.displayName()) ? prop.displayName() : prop.name()).hint(prop.hint())
                    .type(PolicyPropertyTypes.PROPERTY_TYPE.valueOf(prop.type().name()))
                    .objectProperty(annotatedFieldProperty.getName())
                    .placeholder(prop.placeholder())
                    .value(value)
                    .required(prop.required())
                    .group(group)
                    .groupOrder(order)
                    .pattern(prop.pattern())
                    .patternInvalidMessage(prop.patternInvalidMessage())
                    .hidden(prop.hidden())
                    .addSelectableValues(convertToLabelValue(prop.selectableValues()))
                    .addSelectableValues(convertToLabelValue(prop.labelValues())).build();
                properties.add(rule);
                if (!group.equals("")) {
                    if (!groupedProperties.containsKey(group)) {
                        groupedProperties.put(group, new ArrayList<FieldRuleProperty>());
                    }
                    groupedProperties.get(group).add(rule);
                }
            }
            //update layout property
            for (Collection<FieldRuleProperty> groupProps : groupedProperties.values()) {
                for (FieldRuleProperty property : groupProps) {
                    property.setLayout("row");
                }
            }

        }
        return properties;
    }


    /**
     * For a given domain policy class extract the user interface {@link FieldRuleProperty} classes parsing the fields annotated with the {@link PolicyProperty}
     *
     * @param policyClass the domain policy class to parse
     * @return a list of user interface fields annotated with the {@link PolicyProperty}
     */
    public List<FieldRuleProperty> getUiProperties(Class<P> policyClass) {
        AnnotationFieldNameResolver annotationFieldNameResolver = new AnnotationFieldNameResolver(PolicyProperty.class);
        List<AnnotatedFieldProperty> list = annotationFieldNameResolver.getProperties(policyClass);
        List<FieldRuleProperty> properties = new ArrayList<>();
        Map<String, List<FieldRuleProperty>> groupedProperties = new HashMap<>();
        if (hasConstructor(policyClass)) {
            Map<String, Integer> groupOrder = new HashMap<>();
            for (AnnotatedFieldProperty<PolicyProperty> annotatedFieldProperty : list) {
                PolicyProperty prop = annotatedFieldProperty.getAnnotation();
                String value = StringUtils.isBlank(prop.value()) ? null : prop.value();
                String group = prop.group();
                Integer order = 0;
                if (!groupOrder.containsKey(group)) {
                    groupOrder.put(group, order);
                }
                order = groupOrder.get(group);
                order++;
                groupOrder.put(group, order);

                FieldRuleProperty rule = new FieldRulePropertyBuilder(prop.name()).displayName(
                    StringUtils.isNotBlank(prop.displayName()) ? prop.displayName() : prop.name()).hint(prop.hint())
                    .type(PolicyPropertyTypes.PROPERTY_TYPE.valueOf(prop.type().name()))
                    .objectProperty(annotatedFieldProperty.getName())
                    .placeholder(prop.placeholder())
                    .value(value)
                    .required(prop.required())
                    .group(group)
                    .groupOrder(order)
                    .hidden(prop.hidden())
                    .pattern(prop.pattern())
                    .patternInvalidMessage(prop.patternInvalidMessage())
                    .addSelectableValues(convertToLabelValue(prop.selectableValues()))
                    .addSelectableValues(convertToLabelValue(prop.labelValues())).build();
                properties.add(rule);
                if (!group.equals("")) {
                    if (!groupedProperties.containsKey(group)) {
                        groupedProperties.put(group, new ArrayList<FieldRuleProperty>());
                    }
                    groupedProperties.get(group).add(rule);
                }
            }
            //update layout property
            for (Collection<FieldRuleProperty> groupProps : groupedProperties.values()) {
                for (FieldRuleProperty property : groupProps) {
                    property.setLayout("row");
                }
            }
        }
        return properties;
    }

    /**
     * Find all the user interface properies for a given render type
     */
    public List<FieldRuleProperty> findPropertiesMatchingRenderType(List<FieldRuleProperty> properties, final String type) {
        if (StringUtils.isNotBlank(type)) {
            return findPropertiesMatchingRenderTypes(properties, new String[]{type});
        }
        return null;
    }

    public List<FieldRuleProperty> findPropertiesMatchingDefaultValue(List<FieldRuleProperty> properties, final String value) {
        if (StringUtils.isNotBlank(value)) {
            return findPropertiesMatchingRenderTypes(properties, new String[]{value});
        }
        return null;
    }

    public List<FieldRuleProperty> findPropertiesMatchingDefaultValue(List<FieldRuleProperty> properties, final String[] values) {
        final List list = Arrays.asList(values);
        return Lists.newArrayList(Iterables.filter(properties, new Predicate<FieldRuleProperty>() {
            @Override
            public boolean apply(FieldRuleProperty fieldRuleProperty) {
                return list.contains(fieldRuleProperty.getValue());
            }
        }));
    }

    public List<FieldRuleProperty> findPropertiesMatchingRenderTypes(List<FieldRuleProperty> properties, final String[] types) {
        final List list = Arrays.asList(types);
        return Lists.newArrayList(Iterables.filter(properties, new Predicate<FieldRuleProperty>() {
            @Override
            public boolean apply(FieldRuleProperty fieldRuleProperty) {
                return list.contains(fieldRuleProperty.getType());
            }
        }));
    }

    public List<FieldRuleProperty> findPropertiesForRulesetMatchingRenderType(List<? extends BaseUiPolicyRule> rules, final String type) {

        List<FieldRuleProperty> properties = new ArrayList<>();
        for (BaseUiPolicyRule rule : rules) {
            properties.addAll(rule.getProperties());
        }
        return findPropertiesMatchingRenderType(properties, type);
    }

    public List<FieldRuleProperty> findPropertiesForRulesMatchingDefaultValue(List<? extends BaseUiPolicyRule> rules, final String value) {

        List<FieldRuleProperty> properties = new ArrayList<>();
        for (BaseUiPolicyRule rule : rules) {
            properties.addAll(rule.getProperties());
        }
        return findPropertiesMatchingDefaultValue(properties, value);
    }


    public List<FieldRuleProperty> findPropertiesForRulesetMatchingRenderTypes(List<? extends BaseUiPolicyRule> rules, final String[] types) {

        List<FieldRuleProperty> properties = new ArrayList<>();
        for (BaseUiPolicyRule rule : rules) {
            properties.addAll(rule.getProperties());
        }
        return findPropertiesMatchingRenderTypes(properties, types);
    }


    public abstract U buildUiModel(A annotation, P policy, List<FieldRuleProperty> properties);

    public abstract Class<A> getAnnotationClass();


    /**
     * override to do anything special to the resulting obj from the UI
     */
    public void afterFromUiModel(P policy, U uiModel) {

    }

    /**
     * Transform a domain policy rule to a user interface object
     *
     * @param policyRule the domain object
     * @return the user interface object
     */
    @Override
    public U toUIModel(P policyRule) {
        Annotation annotation = policyRule.getClass().getAnnotation(getAnnotationClass());
        List<FieldRuleProperty> properties = getUiProperties(policyRule);
        U rule = buildUiModel((A) annotation, policyRule, properties);
        return rule;
    }

    /**
     * Trasform a user interface object back to the domain policy class
     *
     * @param rule the ui object
     * @return the domain policy transformed
     */
    @Override
    public P fromUiModel(U rule)
        throws PolicyTransformException {
        try {
            P domainPolicy = createClass(rule);

            if (hasConstructor(domainPolicy.getClass())) {

                for (FieldRuleProperty property : rule.getProperties()) {
                    String field = property.getObjectProperty();
                    String value = property.getStringValue();
                    Field f = FieldUtils.getField(domainPolicy.getClass(), field, true);
                    Object objectValue = convertStringToObject(value, f.getType());
                    f.set(domainPolicy, objectValue);
                }
            }
            afterFromUiModel(domainPolicy, rule);
            return domainPolicy;
        } catch (Exception e) {
            throw new PolicyTransformException(e);
        }
    }

    private Object getPropertyValue(BaseUiPolicyRule rule, Class<P> domainPolicyClass, PolicyPropertyRef reference) {
        for (FieldRuleProperty property : rule.getProperties()) {
            String name = property.getName();
            if (name.equalsIgnoreCase(reference.name())) {
                String field = property.getObjectProperty();
                String value = property.getStringValue();
                Field f = FieldUtils.getField(domainPolicyClass, field, true);
                Object objectValue = convertStringToObject(value, f.getType());
                return objectValue;
            }
        }
        return null;
    }


    private boolean hasConstructor(Class<?> policyClass) {
        return policyClass.getConstructors().length > 0;
    }

    private P createClass(BaseUiPolicyRule rule)
        throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException,
               IllegalAccessException {
        P domainPolicy = null;
        String classType = rule.getObjectClassType();
        Class<P> domainPolicyClass = (Class<P>) Class.forName(classType);

        Constructor constructor = null;
        Object[] paramValues = null;
        boolean hasConstructor = false;
        for (Constructor con : domainPolicyClass.getConstructors()) {
            hasConstructor = true;
            int parameterSize = con.getParameterTypes().length;
            paramValues = new Object[parameterSize];
            for (int p = 0; p < parameterSize; p++) {
                Annotation[] annotations = con.getParameterAnnotations()[p];
                Object paramValue = null;
                for (Annotation a : annotations) {
                    if (a instanceof PolicyPropertyRef) {
                        // this is the one we want
                        if (constructor == null) {
                            constructor = con;
                        }
                        //find the value associated to this property
                        paramValue = getPropertyValue(rule, domainPolicyClass, (PolicyPropertyRef) a);

                    }
                }
                paramValues[p] = paramValue;
            }
            if (constructor != null) {
                //exit once we find a constructor with @PropertyRef
                break;
            }

        }

        if (constructor != null) {
            //call that constructor
            try {
                domainPolicy = ConstructorUtils.invokeConstructor(domainPolicyClass, paramValues);
            } catch (NoSuchMethodException e) {
                domainPolicy = domainPolicyClass.newInstance();
            }
        } else {
            //if the class has no public constructor then attempt to call the static instance method
            if (!hasConstructor) {
                //if the class has a static "instance" method on it then call that
                try {
                    domainPolicy = (P) MethodUtils.invokeStaticMethod(domainPolicyClass, "instance", null);
                } catch (NoSuchMethodException | SecurityException | InvocationTargetException e) {
                    domainPolicy = domainPolicyClass.newInstance();
                }
            } else {
                //attempt to create a new instance
                domainPolicy = domainPolicyClass.newInstance();
            }

        }

        return domainPolicy;

    }


    private List<LabelValue> convertToLabelValue(String[] values) {
        if (values != null) {
            List<LabelValue> list = new ArrayList<>();
            for (String value : values) {
                LabelValue labelValue = new LabelValue();
                labelValue.setLabel(value);
                labelValue.setValue(value);
                list.add(labelValue);
            }
            return list;
        }
        return null;
    }


    private LabelValue convertToLabelValue(PropertyLabelValue propertyLabelValue) {
        if (propertyLabelValue != null) {
            LabelValue labelValue = new LabelValue();
            labelValue.setLabel(propertyLabelValue.label());
            labelValue.setValue(propertyLabelValue.value());
            return labelValue;
        }
        return null;
    }

    private List<LabelValue> convertToLabelValue(PropertyLabelValue[] propertyLabelValues) {
        List<LabelValue> labelValues = null;
        if (propertyLabelValues != null) {
            for (PropertyLabelValue propertyLabelValue : propertyLabelValues) {
                if (labelValues == null) {
                    labelValues = new ArrayList<>();
                }
                LabelValue labelValue = convertToLabelValue((propertyLabelValue));
                if (labelValue != null) {
                    labelValues.add(labelValue);
                }
            }
        }
        return labelValues;
    }


    public Object convertStringToObject(String value, Class type) {
        if (type.isEnum()) {
            return Enum.valueOf(type, value);
        } else if (String.class.equals(type)) {
            return value;
        }

        if (StringUtils.isBlank(value)) {
            return null;
        } else if (Number.class.equals(type)) {
            return NumberUtils.createNumber(value);
        } else if (Integer.class.equals(type) || Integer.TYPE.equals(type)) {
            return new Integer(value);
        } else if (Long.class.equals(type) || Long.TYPE.equals(type)) {
            return Long.valueOf(value);
        } else if (Double.class.equals(type) || Double.TYPE.equals(type)) {
            return Double.valueOf(value);
        } else if (Float.class.equals(type) || Float.TYPE.equals(type)) {
            return Float.valueOf(value);
        } else if (Pattern.class.equals(type)) {
            return Pattern.compile(value);
        } else if (Boolean.class.equals(type) || Boolean.TYPE.equals(type)) {
            return BooleanUtils.toBoolean(value);
        } else {
            throw new IllegalArgumentException("Unable to convert the value " + value + " to an object of type " + type.getName());
        }

    }

}