/**
* This file Copyright (c) 2003-2012 Magnolia International
* Ltd. (http://www.magnolia-cms.com). All rights reserved.
*
*
* This file is dual-licensed under both the Magnolia
* Network Agreement and the GNU General Public License.
* You may elect to use one or the other of these licenses.
*
* This file is distributed in the hope that it will be
* useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
* Redistribution, except as permitted by whichever of the GPL
* or MNA you select, is prohibited.
*
* 1. For the GPL license (GPL), you can redistribute and/or
* modify this file under the terms of the GNU General
* Public License, Version 3, as published by the Free Software
* Foundation. You should have received a copy of the GNU
* General Public License, Version 3 along with this program;
* if not, write to the Free Software Foundation, Inc., 51
* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* 2. For the Magnolia Network Agreement (MNA), this file
* and the accompanying materials are made available under the
* terms of the MNA which accompanies this distribution, and
* is available at http://www.magnolia-cms.com/mna.html
*
* Any modifications to this file must keep this entire header
* intact.
*
*/
package info.magnolia.content2bean.impl;
import info.magnolia.cms.core.Content;
import info.magnolia.cms.util.ContentUtil;
import info.magnolia.cms.util.SystemContentWrapper;
import info.magnolia.content2bean.Content2BeanException;
import info.magnolia.content2bean.Content2BeanTransformer;
import info.magnolia.content2bean.PropertyTypeDescriptor;
import info.magnolia.content2bean.TransformationState;
import info.magnolia.content2bean.TypeDescriptor;
import info.magnolia.content2bean.TypeMapping;
import info.magnolia.objectfactory.Classes;
import info.magnolia.objectfactory.ComponentProvider;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.jcr.RepositoryException;
import org.apache.commons.beanutils.BeanUtilsBean;
import org.apache.commons.beanutils.MethodUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.PropertyUtilsBean;
import org.apache.commons.lang.LocaleUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Concrete implementation using reflection and adder methods.
*
* @author philipp
* @version $Id$
*/
@Singleton
public class Content2BeanTransformerImpl implements Content2BeanTransformer, Content.ContentFilter {
private static final Logger log = LoggerFactory.getLogger(Content2BeanTransformerImpl.class);
private final BeanUtilsBean beanUtilsBean;
/**
* @deprecated should not be needed since we pass it around now... or will we ? ... TODO MAGNOLIA-3525
*/
@Inject
private TypeMapping typeMapping;
public Content2BeanTransformerImpl() {
super();
// We use non-static BeanUtils conversion, so we can
// * use our custom ConvertUtilsBean
// * control converters (convertUtilsBean.register()) - we can register them here, locally, as opposed to a
// global ConvertUtils.register()
final EnumAwareConvertUtilsBean convertUtilsBean = new EnumAwareConvertUtilsBean();
// de-register the converter for Class, we do our own conversion in convertPropertyValue()
convertUtilsBean.deregister(Class.class);
this.beanUtilsBean = new BeanUtilsBean(convertUtilsBean, new PropertyUtilsBean());
}
@Override
@Deprecated
public TypeDescriptor resolveType(TransformationState state) throws ClassNotFoundException {
throw new UnsupportedOperationException();
}
/**
* Resolves the <code>TypeDescriptor</code> from current transformation state. Resolving happens in the following
* order:
* <ul>
* <li>checks the class property of the current node
* <li>calls onResolve subclasses should override
* <li>reflection on the parent bean
* <li>in case of a collection/map type call getClassForCollectionProperty
* <li>otherwise use a Map
* </ul>
*/
@Override
public TypeDescriptor resolveType(TypeMapping typeMapping, TransformationState state, ComponentProvider componentProvider) throws ClassNotFoundException {
TypeDescriptor typeDscr = null;
Content node = state.getCurrentContent();
try {
if (node.hasNodeData("class")) {
String className = node.getNodeData("class").getString();
if (StringUtils.isBlank(className)) {
throw new ClassNotFoundException("(no value for class property)");
}
Class<?> clazz = Classes.getClassFactory().forName(className);
typeDscr = typeMapping.getTypeDescriptor(clazz);
}
} catch (RepositoryException e) {
// ignore
log.warn("can't read class property", e);
}
if (typeDscr == null && state.getLevel() > 1) {
TypeDescriptor parentTypeDscr = state.getCurrentType();
PropertyTypeDescriptor propDscr;
if (parentTypeDscr.isMap() || parentTypeDscr.isCollection()) {
if (state.getLevel() > 2) {
// this is not necessarily the parent node of the current
String mapProperyName = state.peekContent(1).getName();
propDscr = state.peekType(1).getPropertyTypeDescriptor(mapProperyName, typeMapping);
if (propDscr != null) {
typeDscr = propDscr.getCollectionEntryType();
}
}
} else {
propDscr = state.getCurrentType().getPropertyTypeDescriptor(node.getName(), typeMapping);
if (propDscr != null) {
typeDscr = propDscr.getType();
}
}
}
typeDscr = onResolveType(typeMapping, state, typeDscr, componentProvider);
if (typeDscr != null) {
// might be that the factory util defines a default implementation for interfaces
final Class<?> type = typeDscr.getType();
typeDscr = typeMapping.getTypeDescriptor(componentProvider.getImplementation(type));
// now that we know the property type we should delegate to the custom transformer if any defined
Content2BeanTransformer customTransformer = typeDscr.getTransformer();
if (customTransformer != null && customTransformer != this) {
TypeDescriptor typeFoundByCustomTransformer = customTransformer.resolveType(typeMapping, state, componentProvider);
// if no specific type has been provided by the
// TODO - is this comparison working ?
if (typeFoundByCustomTransformer != TypeMapping.MAP_TYPE) {
// might be that the factory util defines a default implementation for interfaces
Class<?> implementation = componentProvider.getImplementation(typeFoundByCustomTransformer.getType());
typeDscr = typeMapping.getTypeDescriptor(implementation);
}
}
}
if (typeDscr == null || typeDscr.needsDefaultMapping()) {
if (typeDscr == null) {
log.debug("was not able to resolve type for node [{}] will use a map", node);
}
typeDscr = TypeMapping.MAP_TYPE;
}
log.debug("{} --> {}", node.getHandle(), typeDscr.getType());
return typeDscr;
}
/**
* Called once the type should have been resolved. The resolvedType might be null if no type has been resolved.
* After the call the FactoryUtil and custom transformers are used to get the final type. TODO - check javadoc
*/
protected TypeDescriptor onResolveType(TypeMapping typeMapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
return resolvedType;
}
/**
* @deprecated since 4.5, use {@link #onResolveType(info.magnolia.content2bean.TypeMapping, info.magnolia.content2bean.TransformationState, info.magnolia.content2bean.TypeDescriptor, info.magnolia.objectfactory.ComponentProvider)}
*/
protected TypeDescriptor onResolveType(TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
return onResolveType(getTypeMapping(), state, resolvedType, componentProvider);
}
@Override
public Collection<Content> getChildren(Content node) {
return node.getChildren(this);
}
/**
* Process all nodes except MetaData and nodes with names prefixed by "jcr:".
*/
@Override
public boolean accept(Content content) {
return ContentUtil.EXCLUDE_META_DATA_CONTENT_FILTER.accept(content);
}
@Override
public void setProperty(TransformationState state, PropertyTypeDescriptor descriptor, Map<String, Object> values) {
throw new UnsupportedOperationException();
}
/**
* Do not set class property. In case of a map/collection try to use adder method.
*/
@Override
public void setProperty(TypeMapping mapping, TransformationState state, PropertyTypeDescriptor descriptor, Map<String, Object> values) {
String propertyName = descriptor.getName();
if (propertyName.equals("class")) {
return;
}
Object value = values.get(propertyName);
Object bean = state.getCurrentBean();
if (propertyName.equals("content") && value == null) {
value = new SystemContentWrapper(state.getCurrentContent());
} else if (propertyName.equals("name") && value == null) {
value = state.getCurrentContent().getName();
} else if (propertyName.equals("className") && value == null) {
value = values.get("class");
}
// do no try to set a bean-property that has no corresponding node-property
// else if (!values.containsKey(propertyName)) {
if (value == null) {
return;
}
log.debug("try to set {}.{} with value {}", new Object[] { bean, propertyName, value });
// if the parent bean is a map, we can't guess the types.
if (!(bean instanceof Map)) {
try {
PropertyTypeDescriptor dscr = mapping.getPropertyTypeDescriptor(bean.getClass(), propertyName);
if (dscr.getType() != null) {
// try to use an adder method for a Collection property of the bean
if (dscr.isCollection() || dscr.isMap()) {
log.debug("{} is of type collection, map or /array", propertyName);
Method method = dscr.getAddMethod();
if (method != null) {
log.debug("clearing the current content of the collection/map");
try {
Object col = PropertyUtils.getProperty(bean, propertyName);
if (col != null) {
MethodUtils.invokeExactMethod(col, "clear", new Object[] {});
}
} catch (Exception e) {
log.debug("no clear method found on collection {}", propertyName);
}
Class<?> entryClass = dscr.getCollectionEntryType().getType();
log.debug("will add values by using adder method {}", method.getName());
for (Iterator<Object> iter = ((Map<Object, Object>) value).keySet().iterator(); iter
.hasNext();) {
Object key = iter.next();
Object entryValue = ((Map<Object, Object>) value).get(key);
entryValue = convertPropertyValue(entryClass, entryValue);
if (entryClass.isAssignableFrom(entryValue.getClass())) {
if (dscr.isCollection()) {
log.debug("will add value {}", entryValue);
method.invoke(bean, new Object[] { entryValue });
}
// is a map
else {
log.debug("will add key {} with value {}", key, entryValue);
method.invoke(bean, new Object[] { key, entryValue });
}
}
}
return;
}
log.debug("no add method found for property {}", propertyName);
if (dscr.isCollection()) {
log.debug("transform the values to a collection", propertyName);
value = ((Map<Object, Object>) value).values();
}
} else {
value = convertPropertyValue(dscr.getType().getType(), value);
}
}
} catch (Exception e) {
// do it better
log.error("Can't set property [{}] to value [{}] in bean [{}] for node {} due to {}",
new Object[] { propertyName, value, bean.getClass().getName(),
state.getCurrentContent().getHandle(), e.toString() });
log.debug("stacktrace", e);
}
}
try {
// This uses the converters registered in beanUtilsBean.convertUtilsBean (see constructor of this class)
// If a converter is registered, beanutils will convert value.toString(), not the value object as-is.
// If no converter is registered, then the value Object is set as-is.
// If convertPropertyValue() already converted this value, you'll probably want to unregister the beanutils
// converter.
// some conversions like string to class. Performance of PropertyUtils.setProperty() would be better
beanUtilsBean.setProperty(bean, propertyName, value);
// TODO this also does things we probably don't want/need, i.e nested and indexed properties
} catch (Exception e) {
// do it better
log.error("Can't set property [{}] to value [{}] in bean [{}] for node {} due to {}",
new Object[] { propertyName, value, bean.getClass().getName(),
state.getCurrentContent().getHandle(), e.toString() });
log.debug("stacktrace", e);
}
}
/**
* Most of the conversion is done by the BeanUtils. TODO don't use bean utils conversion since it can't be used for
* the adder methods
*/
@Override
public Object convertPropertyValue(Class<?> propertyType, Object value) throws Content2BeanException {
if (Class.class.equals(propertyType)) {
try {
return Classes.getClassFactory().forName(value.toString());
} catch (ClassNotFoundException e) {
log.error(e.getMessage());
throw new Content2BeanException(e);
}
}
if (Locale.class.equals(propertyType)) {
if (value instanceof String) {
String localeStr = (String) value;
if (StringUtils.isNotEmpty(localeStr)) {
return LocaleUtils.toLocale(localeStr);
}
}
}
if (Collection.class.equals(propertyType) && value instanceof Map) {
// TODO never used ?
return ((Map) value).values();
}
// this is mainly the case when we are flattening node hierarchies
if (String.class.equals(propertyType) && value instanceof Map && ((Map) value).size() == 1) {
return ((Map) value).values().iterator().next();
}
return value;
}
/**
* Use the factory util to instantiate. This is useful to get default implementation of interfaces
*/
@Override
public Object newBeanInstance(TransformationState state, Map properties, ComponentProvider componentProvider) throws Content2BeanException {
// we try first to use conversion (Map --> primitive type)
// this is the case when we flattening the hierarchy?
final Object bean = convertPropertyValue(state.getCurrentType().getType(), properties);
// were the properties transformed?
if (bean == properties) {
try {
// TODO MAGNOLIA-2569 MAGNOLIA-3525 what is going on here ? (added the following if to avoid permanently
// requesting LinkedHashMaps to ComponentFactory)
final Class<?> type = state.getCurrentType().getType();
if (LinkedHashMap.class.equals(type)) {
// TODO - as far as I can tell, "bean" and "properties" are already the same instance of a
// LinkedHashMap, so what are we doing in here ?
return new LinkedHashMap();
} else if (Map.class.isAssignableFrom(type)) {
// TODO ?
log.warn("someone wants another type of map ? " + type);
}
return componentProvider.newInstance(type);
} catch (Throwable e) {
throw new Content2BeanException(e);
}
}
return bean;
}
/**
* Initializes bean by calling its init method if present.
*/
@Override
public void initBean(TransformationState state, Map properties) throws Content2BeanException {
Object bean = state.getCurrentBean();
Method init;
try {
init = bean.getClass().getMethod("init", new Class[] {});
try {
init.invoke(bean); // no parameters
} catch (Exception e) {
throw new Content2BeanException("can't call init method", e);
}
} catch (SecurityException e) {
return;
} catch (NoSuchMethodException e) {
return;
}
log.debug("{} is initialized", bean);
}
@Override
public TransformationState newState() {
return new TransformationStateImpl();
// TODO - do we really need different impls for TransformationState ?
// if so, this was defined in mgnl-beans.properties
// Components.getComponentProvider().newInstance(TransformationState.class);
}
/**
* Returns the default mapping.
*
* @deprecated since 4.5, do not use.
*/
@Override
public TypeMapping getTypeMapping() {
return typeMapping;// TypeMapping.Factory.getDefaultMapping();
}
}