View Javadoc
   package org.jellyfish.implementation;
   
   import java.beans.PropertyDescriptor;
   import java.lang.reflect.InvocationTargetException;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   
  import javax.naming.NamingException;
  import javax.naming.directory.Attribute;
  import javax.naming.directory.Attributes;
  import javax.naming.directory.BasicAttribute;
  import javax.naming.directory.BasicAttributes;
  
  import org.apache.avalon.framework.logger.LogEnabled;
  import org.apache.avalon.framework.service.ServiceException;
  import org.apache.avalon.framework.service.ServiceManager;
  import org.apache.avalon.framework.service.Serviceable;
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.beanutils.ConvertUtils;
  import org.apache.commons.beanutils.Converter;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.jellyfish.ConfigurationManager;
  import org.jellyfish.MappingManager;
  import org.jellyfish.ObjectMapNotFoundException;
  import org.jellyfish.config.AttributeMapping;
  import org.jellyfish.config.ObjectMapping;
  
  public class MappingManagerDefault
  	implements MappingManager, Serviceable, LogEnabled {
  	private static MappingManagerDefault instance;
  
  	private static final String START_DN_ATTRIBUTE = "${";
  	private static final String END_DN_ATTRIBUTE = "}";
  
  	private Map objectMappingCache = new HashMap();
  
  	private ServiceManager serviceManager;
  
  	private org.apache.avalon.framework.logger.Logger logger;
  
  	private ConfigurationManager configurationManager;
  
  	public MappingManagerDefault() {
  	}
  
  	public void service(ServiceManager serviceManager)
  		throws ServiceException {
  		this.serviceManager = serviceManager;
  		try {
  			configurationManager =
  				(ConfigurationManager) serviceManager.lookup(
  					ConfigurationManager.ROLE);
  		} catch (ServiceException e) {
  			e.printStackTrace();
  			throw new RuntimeException(e);
  		}
  	}
  
  	public void enableLogging(
  		org.apache.avalon.framework.logger.Logger logger) {
  		this.logger = logger;
  	}
  
  	private Converter createConverter() {
  		try {
  			return (Converter) serviceManager.lookup(Converter.class.getName());
  		} catch (ServiceException e) {
  			e.printStackTrace();
  			throw new RuntimeException(e);
  		}
  	}
  	public Attributes mapToAttributes(Object object) {
  		Attributes attributes = new BasicAttributes();
  		try {
  			for (Iterator iterator =
  				getObjectMapping(object).getAttributeMappings().iterator();
  				iterator.hasNext();
  				) {
  				AttributeMapping attributeMapping =
  					(AttributeMapping) iterator.next();
  				Object value =
  					getObjectProperty(object, attributeMapping.getJavaName());
  				storeValueInAttributes(
  					attributes,
  					attributeMapping.getLdapName(),
  					value);
  			}
  		} catch (ObjectMapNotFoundException e) {
  			logException(object, e);
  		}
  		return attributes;
  	}
  
  	private void storeValueInAttributes(
  		Attributes attributes,
  		String name,
  		Object value) {
 		if (value instanceof Collection) {
 			for (Iterator iterator = ((Collection) value).iterator();
 				iterator.hasNext();
 				) {
 				Object subValue = iterator.next();
 				storeValueInAttributes(attributes, name, subValue);
 			}
 		} else if (value instanceof Object[]) {
 			for (int index = 0; index < ((Object[]) value).length; index++) {
 				storeValueInAttributes(
 					attributes,
 					name,
 					((Object[]) value)[index]);
 			}
 		} else {
 			if (isMappedClass(value)) {
 				value = getObjectDn(value);
 			}
 
 			if (value != null) {
 				Attribute attribute = attributes.get(name);
 				if (attribute == null) {
 					attribute = new BasicAttribute(name);
 					attributes.put(attribute);
 				}
 				attribute.add(value);
 			}
 		}
 	}
 
 	private boolean isMappedClass(Object value) {
 		return value != null
 			&& objectMappingCache.containsKey(value.getClass());
 	}
 
 	public Object mapFromAttributes(Attributes attributes) {
 		Object object = null;
 		try {
 			ObjectMapping objectMapping = getObjectMapping(attributes);
 			object = Class.forName(objectMapping.getJavaName()).newInstance();
 			Map objectProperties = new HashMap();
 			for (Iterator iterator =
 				objectMapping.getAttributeMappings().iterator();
 				iterator.hasNext();
 				) {
 				AttributeMapping attributeMapping =
 					(AttributeMapping) iterator.next();
 				Attribute attribute =
 					attributes.get(attributeMapping.getLdapName());
 
 				objectProperties.put(
 					attributeMapping.getJavaName(),
 					getValueFromAttribute(
 						attribute,
 						object,
 						attributeMapping.getJavaName(),
 						attributeMapping.getType()));
 			}
 			setObjectProperties(object, objectProperties);
 		} catch (ObjectMapNotFoundException e) {
 			logger.fatalError(e.getMessage(), e);
 		} catch (InstantiationException e) {
 			logger.fatalError(e.getMessage(), e);
 		} catch (IllegalAccessException e) {
 			logger.fatalError(e.getMessage(), e);
 		} catch (ClassNotFoundException e) {
 			logger.fatalError(e.getMessage(), e);
 		} catch (NamingException e) {
 			logger.fatalError(e.getMessage(), e);
 		}
 		return object;
 	}
 
 	private Object getValueFromAttribute(
 		Attribute attribute,
 		Object object,
 		String propertyName,
 		String propertyType)
 		throws
 			ClassNotFoundException,
 			NamingException,
 			InstantiationException,
 			IllegalAccessException {
 		if (attribute == null) {
 			return null;
 		}
 
 		Object value = null;
 		Class propertyClass = null;
 		if (propertyType == null || propertyType.trim().length() == 0) {
 			propertyClass = getTypeOfProperty(object, propertyName);
 		} else {
 			propertyClass = Class.forName(propertyType);
 		}
 
 		if (Collection.class.isAssignableFrom(propertyClass)) {
 			value =
 				getCollectionFromAttribute(
 					attribute,
 					value,
 					propertyName,
 					(Collection) propertyClass.newInstance());
 		} else if (
 			Object[].class.isAssignableFrom(
 				getTypeOfProperty(object, propertyName))) {
 			value = getArrayFromAttribute(attribute, value, propertyName);
 		} else {
 			value = attribute.get();
 		}
 		return value;
 	}
 
 	private Object getInstanceOfProperty(Object object, String propertyName) {
 		try {
 			return getTypeOfProperty(object, propertyName).newInstance();
 		} catch (InstantiationException e) {
 			logException(object, e);
 		} catch (IllegalAccessException e) {
 			logException(object, e);
 		}
 		return null;
 	}
 
 	private Class getTypeOfProperty(Object object, String propertyName) {
 		try {
 			PropertyDescriptor descriptor =
 				PropertyUtils.getPropertyDescriptor(object, propertyName);
 			return descriptor.getPropertyType();
 		} catch (IllegalAccessException e) {
 			logException(object, e);
 		} catch (InvocationTargetException e) {
 			logException(object, e);
 		} catch (NoSuchMethodException e) {
 			logException(object, e);
 		}
 		return null;
 	}
 
 	private Collection getCollectionFromAttribute(
 		Attribute attribute,
 		Object object,
 		String propertyName,
 		Collection container)
 		throws NamingException {
 		if (attribute != null) {
 			for (int index = 0; index < attribute.size(); index++) {
 				container.add(attribute.get(index));
 			}
 		}
 		return container;
 	}
 
 	private Object[] getArrayFromAttribute(
 		Attribute attribute,
 		Object object,
 		String propertyName)
 		throws NamingException {
 		String[] values = new String[attribute.size()];
 		for (int index = 0; index < values.length; index++) {
 			values[index] = (String) attribute.get(index);
 		}
 		return values;
 	}
 
 	private void setObjectProperties(Object object, Map properties) {
 		try {
 			BeanUtils.populate(object, properties);
 		} catch (IllegalAccessException e) {
 			logException(object, e);
 		} catch (InvocationTargetException e) {
 			logException(object, e);
 		} catch (IllegalArgumentException e) {
 			logException(object, e);
 		}
 	}
 
 	private Object getObjectProperty(Object object, String property) {
 		try {
 			return PropertyUtils.getProperty(object, property);
 		} catch (IllegalAccessException e) {
 			logException(object, e);
 		} catch (InvocationTargetException e) {
 			logException(object, e);
 		} catch (NoSuchMethodException e) {
 			logException(object, e);
 		}
 		return "";
 	}
 
 	public ObjectMapping getObjectMapping(Object object)
 		throws ObjectMapNotFoundException {
 		if (objectMappingCache.containsKey(object)) {
 			return (ObjectMapping) objectMappingCache.get(object.getClass());
 		}
 
 		for (Iterator iterator =
 			configurationManager
 				.getConfiguration()
 				.getObjectMappings()
 				.iterator();
 			iterator.hasNext();
 			) {
 			ObjectMapping objectMapping = (ObjectMapping) iterator.next();
 			if (objectMapping
 				.getJavaName()
 				.equals(object.getClass().getName())) {
 				objectMappingCache.put(object.getClass(), objectMapping);
 				ConvertUtils.register(createConverter(), object.getClass());
 				return objectMapping;
 			}
 		}
 
 		throw new ObjectMapNotFoundException(object);
 	}
 
 	public ObjectMapping getObjectMapping(Attributes attributes)
 		throws ObjectMapNotFoundException {
 		String ldapName = null;
 		try {
 			if (attributes.get(OBJECTCLASS) != null) {
 				ldapName = (String) attributes.get(OBJECTCLASS).get();
 				for (Iterator iterator =
 					configurationManager
 						.getConfiguration()
 						.getObjectMappings()
 						.iterator();
 					iterator.hasNext();
 					) {
 					ObjectMapping objectMapping =
 						(ObjectMapping) iterator.next();
 					if (objectMapping
 						.getLdapName()
 						.equals(attributes.get(OBJECTCLASS).get())) {
 						return objectMapping;
 					}
 				}
 			} else {
 				logger.fatalError("No objectclass attribute!");
 			}
 		} catch (NamingException exception) {
 			logger.fatalError(exception.getMessage(), exception);
 		}
 
 		throw new ObjectMapNotFoundException(ldapName);
 	}
 
 	public String getUserDn(String username) {
 
 		String dnPattern = configurationManager.getConfiguration().getUserDn();
 		int dnAttributeStart = dnPattern.indexOf(START_DN_ATTRIBUTE);
 		int dnAttributeEnd = dnPattern.indexOf(END_DN_ATTRIBUTE);
 		String dnAttribute =
 			dnPattern.substring(
 				dnAttributeStart + START_DN_ATTRIBUTE.length(),
 				dnAttributeEnd);
 		StringBuffer dn = new StringBuffer();
 		dn.append(dnPattern.substring(0, dnAttributeStart));
 		dn.append(username);
 		dn.append(
 			dnPattern.substring(dnAttributeEnd + END_DN_ATTRIBUTE.length()));
 		if (configurationManager.getConfiguration().getBaseDn().length() > 0) {
 			dn.append(',');
 		}
 		dn.append(configurationManager.getConfiguration().getBaseDn());
 		return dn.toString();
 	}
 
 	public String getObjectDn(Object object) {
 		try {
 			String dnPattern = getObjectMapping(object).getDn();
 			int dnAttributeStart = dnPattern.indexOf(START_DN_ATTRIBUTE);
 			int dnAttributeEnd = dnPattern.indexOf(END_DN_ATTRIBUTE);
 			String dnAttribute =
 				dnPattern.substring(
 					dnAttributeStart + START_DN_ATTRIBUTE.length(),
 					dnAttributeEnd);
 			StringBuffer dn = new StringBuffer();
 			dn.append(dnPattern.substring(0, dnAttributeStart));
 			dn.append(getObjectProperty(object, dnAttribute));
 			dn.append(
 				dnPattern.substring(
 					dnAttributeEnd + END_DN_ATTRIBUTE.length()));
 			if (configurationManager.getConfiguration().getBaseDn().length()
 				> 0) {
 				dn.append(',');
 			}
 			dn.append(configurationManager.getConfiguration().getBaseDn());
 			return dn.toString();
 		} catch (ObjectMapNotFoundException e) {
 			logException(object, e);
 		}
 		return "";
 	}
 
 	private void logException(Object object, Exception exception) {
 		logger.fatalError("Mapping " + object + ": " + exception.getMessage());
 		exception.printStackTrace();
 	}
 }