/*******************************************************************************
* Copyright (c) 2010 Robert "Unlogic" Olofsson (unlogic@unlogic.se).
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0-standalone.html
******************************************************************************/
package se.unlogic.standardutils.dao;
import se.unlogic.standardutils.annotations.UnsupportedFieldTypeException;
import se.unlogic.standardutils.dao.annotations.DAOManaged;
import se.unlogic.standardutils.dao.annotations.ManyToOne;
import se.unlogic.standardutils.populators.BeanStringPopulator;
import se.unlogic.standardutils.populators.BeanStringPopulatorRegistery;
import se.unlogic.standardutils.populators.QueryParameterPopulator;
import se.unlogic.standardutils.reflection.ReflectionUtils;
import se.unlogic.standardutils.string.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
public class DefaultManyToOneRelation<LocalType,RemoteType, RemoteKeyType> implements ManyToOneRelation<LocalType, RemoteType, RemoteKeyType>{
private final String columnName;
private final Field field;
private QueryParameterPopulator<RemoteKeyType> queryParameterPopulator;
private Method queryMethod;
private final BeanResultSetPopulator<RemoteKeyType> remoteKeyPopulator;
private final Field remoteKeyField;
private final AnnotatedDAOFactory daoFactory;
private AnnotatedDAO<RemoteType> annotatedDAO;
private QueryParameterFactory<RemoteType,RemoteKeyType> queryParameterFactory;
private final Class<RemoteType> remoteClass;
private final Class<RemoteKeyType> remoteRemoteKeyClass;
private boolean initialized;
public DefaultManyToOneRelation(Class<LocalType> beanClass, Class<RemoteType> remoteClass, Class<RemoteKeyType> remoteKeyClass, Field field, Field remoteKeyField, DAOManaged daoManaged, AnnotatedDAOFactory daoFactory) {
this.remoteClass = remoteClass;
this.remoteRemoteKeyClass = remoteKeyClass;
this.field = field;
this.remoteKeyField = remoteKeyField;
this.daoFactory = daoFactory;
if(!StringUtils.isEmpty(daoManaged.columnName())){
this.columnName = daoManaged.columnName();
}else{
this.columnName = field.getName();
}
ReflectionUtils.fixFieldAccess(remoteKeyField);
//TODO use column instead! somehow...
Method resultSetMethod = ResultSetMethods.getColumnNameMethod(remoteKeyClass);
if(resultSetMethod != null){
remoteKeyPopulator = new MethodBasedResultSetPopulator<RemoteKeyType>(resultSetMethod, columnName);
}else{
BeanStringPopulator<RemoteKeyType> typePopulator = BeanStringPopulatorRegistery.getBeanStringPopulator(remoteKeyClass);
if(typePopulator != null){
remoteKeyPopulator = new TypeBasedResultSetPopulator<RemoteKeyType>(typePopulator, columnName);
}else{
throw new UnsupportedFieldTypeException("Unable to find resultset method or type populator for field " + remoteKeyField.getName() + " in " + remoteClass + " when creating many to one relation for field " + field.getName() + " in " + beanClass, field, ManyToOne.class, beanClass);
}
}
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getColumnName()
*/
public String getColumnName(){
return columnName;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getQueryParameterPopulator()
*/
public QueryParameterPopulator<RemoteKeyType> getQueryParameterPopulator(){
if(queryParameterPopulator == null && queryMethod == null){
if(!initialized){
this.init();
}
this.queryParameterPopulator = annotatedDAO.getQueryParameterPopulator(remoteRemoteKeyClass);
}
return queryParameterPopulator;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getQueryMethod()
*/
public Method getQueryMethod(){
if(this.queryMethod == null){
this.queryMethod = PreparedStatementQueryMethods.getObjectQueryMethod();
}
return queryMethod;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getBeanValue(LocalType)
*/
@SuppressWarnings("unchecked")
public RemoteKeyType getBeanValue(LocalType bean){
try {
RemoteType subBean = (RemoteType) field.get(bean);
if(subBean == null){
return null;
}
return (RemoteKeyType)remoteKeyField.get(subBean);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getParamValue(java.lang.Object)
*/
@SuppressWarnings("unchecked")
public RemoteKeyType getParamValue(Object bean) {
try {
if(bean == null){
return null;
}
return (RemoteKeyType) remoteKeyField.get(bean);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#setValue(LocalType, java.sql.ResultSet, java.sql.Connection, java.lang.reflect.Field[])
*/
public void getRemoteValue(LocalType bean, ResultSet resultSet, Connection connection, RelationQuery relationQuery) throws SQLException{
try {
if(!initialized){
this.init();
}
RemoteKeyType keyValue = remoteKeyPopulator.populate(resultSet);
if(keyValue != null){
HighLevelQuery<RemoteType> query = new HighLevelQuery<RemoteType>();
query.addParameter(queryParameterFactory.getParameter(keyValue));
if(relationQuery != null){
query.disableAutoRelations(relationQuery.isDisableAutoRelations());
}
query.addRelations(relationQuery);
RemoteType remoteBeanInstance = annotatedDAO.get(query ,connection);
this.getField().set(bean, remoteBeanInstance);
}
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#add(LocalType, java.sql.Connection, java.lang.reflect.Field)
*/
@SuppressWarnings("unchecked")
public void add(LocalType bean, Connection connection, RelationQuery relationQuery) throws SQLException{
if(!initialized){
this.init();
}
try {
RemoteType remoteBean = (RemoteType) field.get(bean);
if(remoteBean != null){
this.annotatedDAO.add(remoteBean, connection, relationQuery);
}
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#update(LocalType, java.sql.Connection, java.lang.reflect.Field)
*/
@SuppressWarnings("unchecked")
public void update(LocalType bean, Connection connection, RelationQuery relationQuery) throws SQLException{
if(!initialized){
this.init();
}
try {
RemoteType remoteBean = (RemoteType) field.get(bean);
if(remoteBean != null){
this.annotatedDAO.addOrUpdate(remoteBean, connection, relationQuery);
}
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
private void init() {
this.annotatedDAO = this.daoFactory.getDAO(remoteClass);
this.queryParameterFactory = annotatedDAO.getParamFactory(remoteKeyField, remoteRemoteKeyClass);
this.initialized = true;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getField()
*/
public Field getField() {
return field;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getBeanField()
*/
public Field getBeanField() {
return this.field;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#getParamType()
*/
public Class<RemoteType> getParamType() {
return remoteClass;
}
/* (non-Javadoc)
* @see se.unlogic.utils.dao.ManyToOneRelation#isAutoGenerated()
*/
public boolean isAutoGenerated() {
return false;
}
public static <LT,RT,RKT> DefaultManyToOneRelation<LT, RT, RKT> getGenericInstance(Class<LT> beanClass, Class<RT> remoteClass, Class<RKT> remoteKeyClass, Field field, Field remoteField, DAOManaged daoManaged, AnnotatedDAOFactory daoFactory){
return new DefaultManyToOneRelation<LT, RT, RKT>(beanClass, remoteClass, remoteKeyClass, field, remoteField, daoManaged, daoFactory);
}
}