SqlParameterDefinition.java

/**
 * Copyright (C) 2012 the original author or authors.
 *
 * 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.
 */
package co.jirm.mapper.definition;

import static co.jirm.core.util.JirmPrecondition.check;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.base.Strings.isNullOrEmpty;

import java.beans.ConstructorProperties;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.annotation.Nonnull;
import javax.persistence.Column;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Version;

import co.jirm.mapper.SqlObjectConfig;
import co.jirm.mapper.converter.SqlParameterConverter;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.base.Optional;

public class SqlParameterDefinition {
	private final String parameterName;
	private final String sqlName;
	private final Class<?> parameterType;
	private final int order;
	private final boolean id;
	private final boolean version;
	private final boolean generated;
	private final Optional<Enumerated> enumerated;
	private final Optional<SqlParameterObjectDefinition> objectDefinition;
	private final SqlParameterConverter parameterConverter;
	
	
	
	private SqlParameterDefinition(
			SqlParameterConverter parameterConverter, String parameterName, String sqlName, Class<?> parameterType, int order,
			boolean id, boolean version, boolean generated, Optional<Enumerated> enumerated,
			Optional<SqlParameterObjectDefinition> objectDefinition) {
		super();
		this.parameterName = check.notNull(parameterName, "parameterName");
		this.sqlName = check.notNull(sqlName, "sqlName");
		this.parameterType = check.notNull(parameterType, "parameterType");
		this.order = order;
		this.id = id;
		this.version = version;
		this.enumerated = check.notNull(enumerated, "enumerated");
		this.objectDefinition = check.notNull(objectDefinition, "objectDefinition");
		this.parameterConverter = check.notNull(parameterConverter, "parameterConverter");
		this.generated = generated;
	}
	
	static SqlParameterDefinition newSimpleInstance(
			SqlParameterConverter parameterConverter, 
			String parameterName, Class<?> parameterType, 
			int order, String sqlName, boolean id, boolean version, boolean generated, Optional<Enumerated> enumerated) {
		Optional<SqlParameterObjectDefinition> objectDefinition = Optional.absent();
		return new SqlParameterDefinition(parameterConverter, 
				parameterName, 
				sqlName, 
				parameterType, 
				order, 
				id, version, generated, enumerated, objectDefinition);
	}
	
	
	static SqlParameterDefinition newComplexInstance(
			SqlParameterConverter parameterConverter,
			String parameterName,
			@Nonnull
			SqlParameterObjectDefinition objDef, 
			int order, String sqlName) {
		
		Optional<SqlParameterObjectDefinition> objectDefinition = Optional.<SqlParameterObjectDefinition>of(objDef);
		Class<?> parameterType = objectDefinition.get().getObjectDefintion().getObjectType();
		boolean id = false;
		boolean version = false;
		boolean generated = false;
		Optional<Enumerated> enumerated = Optional.absent();
		
		return new SqlParameterDefinition(parameterConverter, 
				parameterName, 
				sqlName, 
				parameterType, 
				order, 
				id, version, generated, enumerated, objectDefinition);
	}
	
	public Object convertToSql(Object original) {
		return this.parameterConverter.convertToSql(original, this);
	}
	
	static Map<String, SqlParameterDefinition> getSqlBeanParameters(Class<?> k, SqlObjectConfig config) {
		Map<String, SqlParameterDefinition> parameters = new LinkedHashMap<String, SqlParameterDefinition>();
		Constructor<?> cons[] = k.getDeclaredConstructors();
		for (Constructor<?> c : cons) {
			if (c.isAnnotationPresent(JsonCreator.class)) {
			  return getSqlBeanParametersFromJsonCreatorConstructor(c, config);
			}
			
			if (c.isAnnotationPresent(ConstructorProperties.class)) {
			  return getSqlBeanParametersFromConstructorProperties(c, config);
			}
		}
		check.argument(! parameters.isEmpty(), 
				"No SQL columns/parameters found for: {}", k);
		return parameters;
	}
	
  public Optional<SqlParameterObjectDefinition> getObjectDefinition() {
		return objectDefinition;
	}

	static SqlParameterDefinition parameterDef(
			SqlObjectConfig config,
			Class<?> objectType, 
			String parameterName, 
			Class<?> parameterType, int order) {
		
		final SqlParameterDefinition definition;
		String sn = null;
		ManyToOne manyToOne = getAnnotation(objectType, parameterName, ManyToOne.class);
		if (manyToOne != null) {
			Class<?> subK = checkNotNull(manyToOne.targetEntity(), "targetEntity not set");
			JoinColumn joinColumn = getAnnotation(objectType, parameterName, JoinColumn.class);
			SqlObjectDefinition<?> od = SqlObjectDefinition.fromClass(subK, config);
			checkState( ! od.getIdParameters().isEmpty(), "No id parameters");
			if (joinColumn != null)
				sn = joinColumn.name();
			if (sn == null)
				sn = config.getNamingStrategy().propertyToColumnName(parameterName);
			FetchType fetch = manyToOne.fetch();
			int depth;
			if (FetchType.LAZY == fetch) {
				depth = 1;
			}
			else {
				depth = config.getMaximumLoadDepth();
				
			}
			SqlParameterObjectDefinition sod = new SqlParameterObjectDefinition(od, depth);
			definition = SqlParameterDefinition.newComplexInstance(config.getConverter(), parameterName, sod, order, sn);
		}
		else {
			Column col = getAnnotation(objectType, parameterName, Column.class);
			if (col != null && ! isNullOrEmpty(col.name()))
				sn = col.name();
			Id id = getAnnotation(objectType, parameterName, Id.class);
			Version version = getAnnotation(objectType, parameterName, Version.class);
			GeneratedValue generated = getAnnotation(objectType, parameterName, GeneratedValue.class);
			Enumerated enumerated = getAnnotation(objectType, parameterName, Enumerated.class);
			
			boolean idFlag = id != null;
			boolean versionFlag = version != null;
			boolean generatedFlag = generated != null;
			if (sn == null)
				sn = config.getNamingStrategy().propertyToColumnName(parameterName);
			definition = SqlParameterDefinition.newSimpleInstance(config.getConverter(), parameterName, 
					parameterType, order, sn, idFlag, versionFlag, generatedFlag, Optional.fromNullable(enumerated));
		}
		return definition;
	}

	private static <T extends Annotation> T getAnnotation(Class<?> k, String value, Class<T> a) {
		try {
			Field f = k.getDeclaredField(value);
			return f.getAnnotation(a);
		} catch (SecurityException e) {
			throw new RuntimeException(e);
		} catch (NoSuchFieldException e) {
			throw new RuntimeException(e);
		}
	}
	
	public String getParameterName() {
		return parameterName;
	}
	public Class<?> getParameterType() {
		return parameterType;
	}
	public int getOrder() {
		return order;
	}
	public String sqlName() {
		return sqlName;
	}
	public String sqlName(String prefix) {
		if (prefix != null)
			return prefix + "." + sqlName;
		return sqlName;
	}
	
	public boolean isId() {
		return id;
	}
	public boolean isComplex() {
		return this.getObjectDefinition().isPresent();
	}
	
	public boolean isVersion() {
		return version;
	}
	public boolean isGenerated() {
		return generated;
	}
	
	public Optional<Enumerated> getEnumerated() {
		return enumerated;
	}
	
	//@SuppressWarnings("unchecked")
	public Optional<Object> valueFrom(Map<String,Object> m) {
		Object o = m.get(this.getParameterName());
		return Optional.fromNullable(o);
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + (id ? 1231 : 1237);
		result = prime * result + ((objectDefinition == null) ? 0 : objectDefinition.hashCode());
		result = prime * result + order;
		result = prime * result + ((parameterName == null) ? 0 : parameterName.hashCode());
		result = prime * result + ((parameterType == null) ? 0 : parameterType.hashCode());
		result = prime * result + ((sqlName == null) ? 0 : sqlName.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		SqlParameterDefinition other = (SqlParameterDefinition) obj;
		if (id != other.id)
			return false;
		if (objectDefinition == null) {
			if (other.objectDefinition != null)
				return false;
		}
		else if (!objectDefinition.equals(other.objectDefinition))
			return false;
		if (order != other.order)
			return false;
		if (parameterName == null) {
			if (other.parameterName != null)
				return false;
		}
		else if (!parameterName.equals(other.parameterName))
			return false;
		if (parameterType == null) {
			if (other.parameterType != null)
				return false;
		}
		else if (!parameterType.equals(other.parameterType))
			return false;
		if (sqlName == null) {
			if (other.sqlName != null)
				return false;
		}
		else if (!sqlName.equals(other.sqlName))
			return false;
		return true;
	}
	
	private static Map<String, SqlParameterDefinition> getSqlBeanParametersFromJsonCreatorConstructor(Constructor<?> c, SqlObjectConfig config) {
	  Map<String, SqlParameterDefinition> parameters = new LinkedHashMap<String, SqlParameterDefinition>();
    Annotation[][] aas = c.getParameterAnnotations();
    Class<?>[] pts = c.getParameterTypes();
    if (aas == null || aas.length == 0) {
      return parameters;
    }
    
    for (int i = 0; i < aas.length; i++) {
      Annotation[] as = aas[i];
      Class<?> parameterType = pts[i];
      for (int j = 0; j < as.length; j++) {
        Annotation a = as[j];
        if (JsonProperty.class.equals(a.annotationType())) {
          JsonProperty p = (JsonProperty) a;
          String value = p.value();
          final SqlParameterDefinition definition = parameterDef(config, c.getDeclaringClass(), value, parameterType, i);
          parameters.put(value, definition);
        }
      }
      
    }
    
    return parameters;
	}
  
  private static Map<String, SqlParameterDefinition> getSqlBeanParametersFromConstructorProperties(Constructor<?> c, SqlObjectConfig config) {
    Map<String, SqlParameterDefinition> parameters = new LinkedHashMap<String, SqlParameterDefinition>();
    
    String[] constructorProperties = c.getAnnotation(ConstructorProperties.class).value();
    Class<?>[] pts = c.getParameterTypes();

    for (int i = 0; i < pts.length; i++) {
      parameters.put(constructorProperties[i], parameterDef(config, c.getDeclaringClass(), constructorProperties[i], pts[i], i));
    }
    
    return parameters;
  }
}