<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping default-lazy="false" default-cascade="all">
   <class name="com.fidelity.shares.domain.ServiceProviderElection"
      table="service_provider_election" lazy="false">
      <id name="id" column="id" type="long">
         <generator class="sequence">
            <param name="sequence">
               service_provider_election_seq
            </param>
         </generator>
      </id>
      <property name="electionType" column="election_type">
         <type name="com.fidelity.shares.domain.IntEnumUserType">
            <param name="enumClass">
               com.fidelity.shares.domain.ElectionType
            </param>
         </type>
      </property>
      <property name="activeStatus" column="active_status">
         <type name="com.fidelity.shares.domain.IntEnumUserType">
            <param name="enumClass">
               com.fidelity.shares.domain.ActiveStatus
            </param>
         </type>
      </property>
      <many-to-one name="accessType" column="access_type_id"
         cascade="none" />
      <many-to-one name="serviceProvider" column="service_provider_id"
         cascade="none">
      </many-to-one>
      <many-to-one cascade="none" name="confirmation"
         column="confirmation_id">
      </many-to-one>
      <many-to-one cascade="none" name="taxEntity"
         column="tax_entity_id">
      </many-to-one>
      <many-to-one cascade="none" name="electionEvent"
         column="event_id">
      </many-to-one>
   </class>
</hibernate-mapping>

public ServiceProviderElection findCurrentElection(TaxEntity taxEntity) {
      Object[] params = { taxEntity, ActiveStatus.ACTIVE };

      List<ServiceProviderElection> serviceProviderElection = hibernateTemplate
            .find(
                  "from ServiceProviderElection where "
                        + "taxEntity=? and activeStatus=? order by confirmation.confirmDate desc",
                  params);

      if (serviceProviderElection != null
            && !serviceProviderElection.isEmpty())
         return serviceProviderElection.get(0);

      return null;
   }

public class ServiceProviderElection extends IDObject implements Cloneable {   
   private TaxEntity taxEntity;
   private AccessType accessType;
   private ServiceProvider serviceProvider;
   private Confirmation confirmation;
   private ElectionEvent electionEvent;
   private ActiveStatus activeStatus;
   private ElectionType    electionType;
   

   public ServiceProviderElection() {
      super();
   }

   public ServiceProvider getServiceProvider() {
      return serviceProvider;
   }

   public void setServiceProvider(ServiceProvider serviceProvider) {
      this.serviceProvider = serviceProvider;
   }

   public Confirmation getConfirmation() {
      return confirmation;
   }

   public void setConfirmation(Confirmation confirmation) {
      this.confirmation = confirmation;
   }

   public TaxEntity getTaxEntity() {
      return taxEntity;
   }

   public void setTaxEntity(TaxEntity taxEntity) {
      this.taxEntity = taxEntity;
   }

   public void setAccessType(AccessType accessType) {
      this.accessType = accessType;
   }
   
   public AccessType getAccessType() {
      return accessType;
   }

   public ElectionType getElectionType() {
      return electionType;
   }

   public void setElectionType(ElectionType electionType) {
      this.electionType = electionType;
   }

   public ElectionEvent getElectionEvent() {
      return electionEvent;
   }

   public void setElectionEvent(ElectionEvent electionEvent) {
      this.electionEvent = electionEvent;
   }

   public ActiveStatus getActiveStatus() {
      return activeStatus;
   }

   public void setActiveStatus(ActiveStatus activeStatus) {
      this.activeStatus = activeStatus;      
   }
   
   @Override
   public ServiceProviderElection clone(){      
      ServiceProviderElection newElection = new ServiceProviderElection();
      
      newElection.setAccessType(this.getAccessType());
      newElection.setActiveStatus(this.getActiveStatus());
      newElection.setConfirmation(this.getConfirmation());
      newElection.setElectionEvent(this.getElectionEvent());
      newElection.setElectionType(this.getElectionType());
      newElection.setId(this.getId());
      newElection.setServiceProvider(this.getServiceProvider());
      newElection.setTaxEntity(this.getTaxEntity());
      
      return newElection;
   }

public enum ActiveStatus{
   ACTIVE(1), INACTIVE(2);

   private ActiveStatus(int value) {
      this.value = value;
   }

   private int value;

   public int toInt() {
      return value;
   }

   public static ActiveStatus fromInt(int value) throws Exception {
      switch (value) {
      case 1:
         return ACTIVE;
      case 2:
         return INACTIVE;
      default:
         throw new Exception(String.format(
               "Int value %s cannot be translated to an ElectionType",
               value));
      }
   }
}
}


public class GenericEnumUserType implements UserType, ParameterizedType {
   private static final String DEFAULT_IDENTIFIER_METHOD_NAME = "name";
   private static final String DEFAULT_VALUE_OF_METHOD_NAME = "valueOf";

   public String getDefaultIdentifierMethodName() {
      return DEFAULT_IDENTIFIER_METHOD_NAME;
   }

   public String getDefaultValueOfMethodName() {
      return DEFAULT_VALUE_OF_METHOD_NAME;
   }

   @SuppressWarnings("unchecked")
   private Class<? extends Enum> enumClass;
   private Class<?> identifierType;
   private Method identifierMethod;
   private Method valueOfMethod;
   private NullableType type;
   private int[] sqlTypes;

   public void setParameterValues(Properties parameters) {
      String enumClassName = parameters.getProperty("enumClass");
      try {
         enumClass = Class.forName(enumClassName).asSubclass(Enum.class);
      } catch (ClassNotFoundException cfne) {
         throw new HibernateException("Enum class not found", cfne);
      }

      String identifierMethodName = parameters.getProperty(
            "identifierMethod", this.getDefaultIdentifierMethodName());

      try {
         identifierMethod = enumClass.getMethod(identifierMethodName,
               new Class[0]);
         identifierType = identifierMethod.getReturnType();
      } catch (Exception e) {
         throw new HibernateException("Failed to obtain identifier method",
               e);
      }

      type = (NullableType) TypeFactory.basic(identifierType.getName());

      if (type == null)
         throw new HibernateException("Unsupported identifier type "
               + identifierType.getName());

      sqlTypes = new int[] { type.sqlType() };

      String valueOfMethodName = parameters.getProperty("valueOfMethod",
            this.getDefaultValueOfMethodName());

      try {
         valueOfMethod = enumClass.getMethod(valueOfMethodName,
               new Class[] { identifierType });
      } catch (Exception e) {
         throw new HibernateException("Failed to obtain valueOf method", e);
      }
   }

   @SuppressWarnings("unchecked")
   public Class returnedClass() {
      return enumClass;
   }

   public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
         throws HibernateException, SQLException {
      Object identifier = type.get(rs, names[0]);
      if (rs.wasNull()) {
         return null;
      }

      try {
         return valueOfMethod.invoke(enumClass, new Object[] { identifier });
      } catch (Exception e) {
         throw new HibernateException(
               "Exception while invoking valueOf method '"
                     + valueOfMethod.getName() + "' of "
                     + "enumeration class '" + enumClass + "'", e);
      }
   }

   public void nullSafeSet(PreparedStatement st, Object value, int index)
         throws HibernateException, SQLException {
      try {
         if (value == null) {
            st.setNull(index, type.sqlType());
         } else {
            Object identifier = identifierMethod.invoke(value,
                  new Object[0]);
            type.set(st, identifier, index);
         }
      } catch (Exception e) {
         throw new HibernateException(
               "Exception while invoking identifierMethod '"
                     + identifierMethod.getName() + "' of "
                     + "enumeration class '" + enumClass + "'", e);
      }
   }

   public int[] sqlTypes() {
      return sqlTypes;
   }

   public Object assemble(Serializable cached, Object owner)
         throws HibernateException {
      return cached;
   }

   public Object deepCopy(Object value) throws HibernateException {
      return value;
   }

   public Serializable disassemble(Object value) throws HibernateException {
      return (Serializable) value;
   }

   public boolean equals(Object x, Object y) throws HibernateException {
      return x == y;
   }

   public int hashCode(Object x) throws HibernateException {
      return x.hashCode();
   }

   public boolean isMutable() {
      return false;
   }

   public Object replace(Object original, Object target, Object owner)
         throws HibernateException {
      return original;
   }
}

public class IntEnumUserType extends GenericEnumUserType {

   private static final String DEFAULT_IDENTIFIER_METHOD_NAME = "toInt";
   private static final String DEFAULT_VALUE_OF_METHOD_NAME = "fromInt";

   @Override
   public String getDefaultIdentifierMethodName() {
      return DEFAULT_IDENTIFIER_METHOD_NAME;
   }

   @Override
   public String getDefaultValueOfMethodName() {
      return DEFAULT_VALUE_OF_METHOD_NAME;
   }
}