/*******************************************************************************
* 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.collections.CollectionUtils;
import se.unlogic.standardutils.dao.annotations.DAOManaged;
import se.unlogic.standardutils.dao.annotations.Key;
import se.unlogic.standardutils.dao.annotations.SimplifiedRelation;
import se.unlogic.standardutils.dao.enums.Order;
import se.unlogic.standardutils.dao.querys.ArrayListQuery;
import se.unlogic.standardutils.dao.querys.PreparedStatementQuery;
import se.unlogic.standardutils.dao.querys.UpdateQuery;
import se.unlogic.standardutils.populators.BeanStringPopulator;
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.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class SimplifiedOneToManyRelation<LocalType, RemoteType> implements OneToManyRelation<LocalType, RemoteType> {
private final AnnotatedDAO<LocalType> localDAO;
private final Field field;
private String selectSQL;
private String insertSQL;
private String deleteSQL;
private boolean preserveListOrder;
private String indexColumnName;
private QueryParameterPopulator<RemoteType> queryParameterPopulator;
private Method preparedStatementMethod;
private BeanResultSetPopulator<RemoteType> beanResultSetPopulator;
private Field keyField;
private Column<LocalType, ?> keyColumn;
private final String remoteTableName;
private String remoteKeyColumnName;
private final String remoteValueColumnName;
private Order order;
private boolean initialized;
@SuppressWarnings("unchecked")
public SimplifiedOneToManyRelation(Class<LocalType> beanClass, Class<RemoteType> remoteClass, Field field, AnnotatedDAO<LocalType> localDAO, List<? extends BeanStringPopulator<?>> typePopulators, List<? extends QueryParameterPopulator<?>> queryParameterPopulators) {
super();
this.localDAO = localDAO;
this.field = field;
SimplifiedRelation simplifiedRelation = field.getAnnotation(SimplifiedRelation.class);
remoteKeyColumnName = simplifiedRelation.remoteKeyColumnName();
remoteValueColumnName = simplifiedRelation.remoteValueColumnName();
order = simplifiedRelation.order();
if(simplifiedRelation.addTablePrefix()){
if(simplifiedRelation.deplurifyTablePrefix() && localDAO.getTableName().endsWith("s")){
remoteTableName = localDAO.getTableName().substring(0, localDAO.getTableName().length()-1) + simplifiedRelation.table();
}else{
remoteTableName = localDAO.getTableName() + simplifiedRelation.table();
}
}else{
remoteTableName = simplifiedRelation.table();
}
if (!StringUtils.isEmpty(simplifiedRelation.keyField())) {
try {
keyField = ReflectionUtils.getField(beanClass, simplifiedRelation.keyField());
if (keyField == null) {
throw new RuntimeException("Unable to find field " + simplifiedRelation.keyField() + " in " + beanClass.getClass());
}
} catch (SecurityException e) {
throw new RuntimeException(e);
}
} else {
List<Field> fields = ReflectionUtils.getFields(beanClass);
for (Field localBeanField : fields) {
if (localBeanField.isAnnotationPresent(DAOManaged.class) && localBeanField.isAnnotationPresent(Key.class)) {
if (this.keyField == null) {
keyField = localBeanField;
} else {
throw new RuntimeException("Multiple fields marked with @Key annotation found in class " + beanClass + " therefore keyField has to set on the @SimplifiedRelation annotation of field " + field.getName());
}
}
}
}
if (queryParameterPopulators != null) {
for (QueryParameterPopulator<?> queryParameterPopulator : queryParameterPopulators) {
if (queryParameterPopulator.getType().equals(remoteClass)) {
this.queryParameterPopulator = (QueryParameterPopulator<RemoteType>) queryParameterPopulator;
}
}
}
if (this.queryParameterPopulator == null) {
preparedStatementMethod = PreparedStatementQueryMethods.getQueryMethod(remoteClass);
if (preparedStatementMethod == null) {
throw new RuntimeException("Unable to to find a query parameter populator or prepared statement method matching " + remoteClass + " of @SimplfiedRelation and @OneToMany annotated field " + field.getName() + " in " + beanClass);
}
}
if (typePopulators != null) {
for (BeanStringPopulator<?> typePopulator : typePopulators) {
if (typePopulator.getType().equals(remoteClass)) {
beanResultSetPopulator = new TypeBasedResultSetPopulator<RemoteType>((BeanStringPopulator<RemoteType>) typePopulator, remoteValueColumnName);
}
}
}
if (beanResultSetPopulator == null) {
Method resultSetMethod = ResultSetMethods.getColumnNameMethod(remoteClass);
if (resultSetMethod != null) {
beanResultSetPopulator = new MethodBasedResultSetPopulator<RemoteType>(resultSetMethod, remoteValueColumnName);
} else {
throw new RuntimeException("Unable to to find a type populator or resultset method matching " + remoteClass + " of @SimplfiedRelation and @OneToMany annotated field " + field.getName() + " in " + beanClass);
}
}
if(simplifiedRelation.preserveListOrder()){
if(StringUtils.isEmpty(simplifiedRelation.indexColumn())){
throw new RuntimeException("Preserve list order enabled but no index column specified for @SimplifiedRelation annotated field " + field.getName() + " in " + beanClass);
}
preserveListOrder = true;
indexColumnName = simplifiedRelation.indexColumn();
}
}
private void init() {
this.keyColumn = localDAO.getColumn(keyField);
if (StringUtils.isEmpty(remoteKeyColumnName)) {
remoteKeyColumnName = keyColumn.getColumnName();
}
this.deleteSQL = "DELETE FROM " + remoteTableName + " WHERE " + remoteKeyColumnName + "=?";
if(preserveListOrder){
this.selectSQL = "SELECT * FROM " + remoteTableName + " WHERE " + remoteKeyColumnName + " = ? ORDER BY " + indexColumnName + " " + order;
this.insertSQL = "INSERT INTO " + remoteTableName + "(" + remoteKeyColumnName + "," + remoteValueColumnName + "," + indexColumnName + ") VALUES (?,?,?)";
}else{
this.selectSQL = "SELECT * FROM " + remoteTableName + " WHERE " + remoteKeyColumnName + " = ? ORDER BY " + remoteValueColumnName + " " + order;
this.insertSQL = "INSERT INTO " + remoteTableName + "(" + remoteKeyColumnName + "," + remoteValueColumnName + ") VALUES (?,?)";
}
this.initialized = true;
}
/*
* (non-Javadoc)
*
* @see se.unlogic.utils.dao.OneToManyRelation#setValue(LocalType, java.sql.Connection, java.lang.reflect.Field[])
*/
public void getRemoteValue(LocalType bean, Connection connection, RelationQuery relationQuery) throws SQLException {
if (!initialized) {
init();
}
try {
ArrayListQuery<RemoteType> query = new ArrayListQuery<RemoteType>(connection, false, selectSQL, beanResultSetPopulator);
setKey(query, bean);
ArrayList<RemoteType> list = query.executeQuery();
if (list != null) {
CollectionUtils.removeNullValues(list);
}
field.set(bean, list);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
private void setKey(PreparedStatementQuery query, LocalType bean) throws SQLException {
if (keyColumn.getQueryParameterPopulator() != null) {
keyColumn.getQueryParameterPopulator().populate(query, 1, bean);
} else {
try {
keyColumn.getQueryMethod().invoke(query, 1, keyColumn.getBeanValue(bean));
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
}
private void setValue(RemoteType value, UpdateQuery query) throws SQLException {
if (queryParameterPopulator != null) {
queryParameterPopulator.populate(query, 2, value);
} else {
try {
preparedStatementMethod.invoke(query, 2, value);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
}
/*
* (non-Javadoc)
*
* @see se.unlogic.utils.dao.OneToManyRelation#add(LocalType, java.sql.Connection, java.lang.reflect.Field[])
*/
@SuppressWarnings("unchecked")
public void add(LocalType bean, Connection connection, RelationQuery relationQuery) throws SQLException {
if (!initialized) {
init();
}
try {
List<RemoteType> values = (List<RemoteType>) field.get(bean);
if (values != null) {
int listIndex = 0;
for (RemoteType value : values) {
UpdateQuery query = new UpdateQuery(connection, false, insertSQL);
setKey(query, bean);
setValue(value, query);
if(preserveListOrder){
query.setInt(3, listIndex);
listIndex++;
}
query.executeUpdate();
}
}
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/*
* (non-Javadoc)
*
* @see se.unlogic.utils.dao.OneToManyRelation#update(LocalType, java.sql.Connection, java.lang.reflect.Field[])
*/
public void update(LocalType bean, Connection connection, RelationQuery relationQuery) throws SQLException {
if (!initialized) {
init();
}
UpdateQuery query = new UpdateQuery(connection, false, deleteSQL);
setKey(query, bean);
query.executeUpdate();
this.add(bean, connection, relationQuery);
}
public static <LT, RT> OneToManyRelation<LT, RT> getGenericInstance(Class<LT> beanClass, Class<RT> remoteClass, Field field, AnnotatedDAO<LT> localDAO, List<? extends BeanStringPopulator<?>> typePopulators, List<? extends QueryParameterPopulator<?>> queryParameterPopulators) {
return new SimplifiedOneToManyRelation<LT, RT>(beanClass, remoteClass, field, localDAO, typePopulators, queryParameterPopulators);
}
}