package com.stevideter
 
import org.codehaus.groovy.grails.plugins.springsecurity.GormUserDetailsService
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
 
class CaseInsensitiveUserDetailsService extends GormUserDetailsService {
 
	/**
	 * make username case insensitive. Since we're using in a specific app,
	 * let's directly use the known class and property name
	 */
	UserDetails loadUserByUsername(String username, boolean loadRoles) 
			throws UsernameNotFoundException {
		// in this example, I used Person as my domain class
		Person.withTransaction { status ->
			def user = Person.findByUsernameIlike(username)
			if (!user) {
				log.warn "User not found: $username"
				throw new UsernameNotFoundException('User not found', username)
			}
 
			Collection<GrantedAuthority> authorities = 
				loadAuthorities(user, username, loadRoles)
			createUserDetails user, authorities
		}
	}
}

beans = {
	userDetailsService(com.stevideter.CaseInsensitiveUserDetailsService)
}

package com.stevideter
 
import org.codehaus.groovy.grails.plugins.springsecurity.GormUserDetailsService
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils
 
class DynamicCaseInsensitiveUserDetailsService extends GormUserDetailsService {
 
	def grailsApplication
 
	UserDetails loadUserByUsername(String username, boolean loadRoles)
			throws UsernameNotFoundException {
		def conf = SpringSecurityUtils.securityConfig
		String userClassName = conf.userLookup.userDomainClassName
		def dc = grailsApplication.getDomainClass(userClassName)
		if (!dc) {
			throw new RuntimeException("The specified user domain class '$userClassName' is not a domain class")
		}
 
		Class<?> User = dc.clazz
 
		User.withTransaction { status ->
			// this time we'll use where plus a DetachedCriteria closure 
			// with =~ for case insensitivity
			def user = User.where{
				(conf.userLookup.usernamePropertyName) =~ username
			}.find()
			if (!user) {
				log.warn "User not found: $username"
				throw new UsernameNotFoundException('User not found', username)
			}
			log.debug "found user"
 
			Collection<GrantedAuthority> authorities = 
				loadAuthorities(user, username, loadRoles)
			createUserDetails user, authorities
		}
	}
}

beans = {
	userDetailsService(com.stevideter.DynamicCaseInsensitiveUserDetailsService) {
		grailsApplication = ref('grailsApplication')
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  xmlns:s1="http://stevideter.com/webservice">
    <xs:element name="ServiceFault" type="s1:ServiceFault"/>
    <xs:complexType name="ServiceFault">
        <xs:sequence>
            <xs:element name="errorCode" type="xs:string" minOccurs="0" maxOccurs="1"/>
	    <xs:element name="errorDescription" type="xs:string" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
    </xs:complexType>
</xs:schema>

package com.stevideter.webservice;
 
import org.springframework.ws.soap.server.endpoint.annotation.FaultCode;
import org.springframework.ws.soap.server.endpoint.annotation.SoapFault;
 
import com.stevideter.webservice.ServiceFaultDocument;
/**
 * An exception that carries a ServiceFault document for inclusion in 
 * the SoapFault
 * @author stevi.deter
 *
 */
@SoapFault(faultCode = FaultCode.SERVER,faultStringOrReason="SERVICE-ERR",locale="en")
public class ServiceFaultException extends Exception {
 
	private static final long serialVersionUID = 1L;
	private ServiceFaultDocument faultMessage;
 
	public ServiceFaultException() {
		super("ServiceFaultException");
	}
 
	public ServiceFaultException(String s) {
		super(s);
	}
 
	public ServiceFaultException(String s, Throwable ex) {
		super(s, ex);
	}
 
	public ServiceFaultException(String s, Throwable ex, ServiceFaultDocument msg) {
		super(s,ex);
		setFaultMessage(msg);
 
	}
 
	public void setFaultMessage(ServiceFaultDocument msg) {
		faultMessage = msg;
	}
 
	public ServiceFaultDocument getFaultMessage() {
		return faultMessage;
	}
 
}

package com.stevideter.webservice.soap.server.endpoint;
 
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
 
import org.springframework.ws.soap.SoapFault;
import org.springframework.ws.soap.SoapFaultDetail;
import org.springframework.ws.soap.server.endpoint.SoapFaultMappingExceptionResolver;
import org.springframework.xml.transform.StringSource;
 
import com.stevideter.webservice.ServiceFaultException;
import com.stevideter.webservice.ServiceFaultDocument;
 
public class DetailSoapFaultDefinitionExceptionResolver extends
		SoapFaultMappingExceptionResolver {
 
	@Override
	protected void customizeFault(Object endpoint, Exception ex, SoapFault fault) {
		ServiceFaultException msg = null;
		if (ex instanceof ServiceFaultException) {
			msg = (ServiceFaultException) ex;
		} else {
			msg = createFaultMessage(ex);
		}
		addServiceFaultDetail(msg, fault);
	}
 
	private void addServiceFaultDetail(ServiceFaultException msg, SoapFault fault)
			throws TransformerFactoryConfigurationError {
		Transformer trn;
		try {
			trn = TransformerFactory.newInstance().newTransformer();
			SoapFaultDetail faultDetail = fault.addFaultDetail();
			Result result = faultDetail.getResult();
			ServiceFaultDocument doc = msg.getFaultMessage();
			if (doc == null) {
				logger.error("ServiceFaultException thrown with no serviceFaultDocument!",msg);
			} else {
				trn.transform(new StringSource(doc.toString()), result);
			}
		} catch (TransformerException e) {
			logger.error("problem with XML transform: ", e);
		}
	}
 
	private ServiceFaultException createFaultMessage(Exception e) {
		ServiceFaultDocument faultDocument = ServiceFaultDocument.Factory.newInstance();
		ServiceFault fault = faultDocument.addNewServiceFault();
		fault.setErrorCode("SERVICE-ERR");
		fault.setErrorDescription(e.getMessage());
		ServiceFaultException faultMsg = new ServiceFaultException(e.getMessage(),e,faultDocument);
		return faultMsg;
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<!-- rest of web service bean def's elided -->
 
    <bean id="exceptionResolver"
	        class="com.stevideter.webservice.soap.server.endpoint.DetailSoapFaultDefinitionExceptionResolver">
        <property name="defaultFault" value="SERVER"/>
        <property name="exceptionMappings">
            <value>
	    com.stevideter.webservice.ServiceFaultException=SERVER,FaultMsg
            </value>
	</property>
    </bean>
</beans>

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
   <SOAP-ENV:Header/>
   <SOAP-ENV:Body>
      <SOAP-ENV:Fault>
         <faultcode>SOAP-ENV:Server</faultcode>
         <faultstring xml:lang="en">FaultMsg</faultstring>
         <detail>
            <ServiceFault xmlns="http://stevideter.com/webservice">
               <errorCode xmlns="">SERVICE-ERR</errorCode>
               <errorDescription xmlns="">you can't do that!</errorDescription>
            </ServiceFault>
         </detail>
      </SOAP-ENV:Fault>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Session session = sessionFactory1.openSession();
Transaction tx = session.beginTransaction();
Item item = (Item) session.get(Item.class, new Long(1234));
tx.commit();
session.close(); // end of first session, item is detached
 
item.getId(); // The database identity is "1234"
item.setDescription("my new description");
Session session2 = sessionFactory.openSession();
Transaction tx2 = session2.beginTransaction();
Item item2 = (Item) session2.get(Item.class, new Long(1234));
session2.update(item); // Throws NonUniqueObjectException
tx2.commit();
session2.close();

Session session = sessionFactory1.openSession();
Transaction tx = session.beginTransaction();
Item item = (Item) session.get(Item.class, new Long(1234));
tx.commit();
session.close(); // end of first session, item is detached
 
item.getId(); // The database identity is "1234"
item.setDescription("my new description");
Session session2 = sessionFactory.openSession();
Transaction tx2 = session2.beginTransaction();
Item item2 = (Item) session2.get(Item.class, new Long(1234));
Item item3 = session2.merge(item); // Success!
tx2.commit();
session2.close();

package com.stevideter.domain;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
 
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;
 
import org.apache.commons.collections.CollectionUtils;
 
@Entity
@Table(name = "ITEM")
public class Item implements Serializable {
 
  private static final long serialVersionUID = -7990110946186412551L;
  private Integer id;
  private List bids = new ArrayList();
 
  @Id
  public Integer getId() {
    return id;
  }
 
  public void setId(Integer id) {
    this.id = id;
  }
 
  @OneToMany(mappedBy="item",cascade=CascadeType.ALL)
  @OrderBy("userId,date,amount")
  public List getBids() {
    return bids;
  }
 
  private void setBids(List bids) {
    this.bids = bids;
  }
 
  public void addBid(Bid bid) {
    if (CollectionUtils.isEmpty(bids)) { bids = new ArrayList();}
    bids.add(bid);
    bid.setItem(this);
  }
 
  public void removeBid(Bid bid) {
    if (CollectionUtils.isNotEmpty(bids)) {
      bids.remove(bid);
    }
  }
 
}

package com.stevideter.domain;
 
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
 
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
 
@Entity
@Table(name = "BID")
public class Bid implements Serializable {
 
  private static final long serialVersionUID = 8165733510722884274L;
  private Integer id;
  private Item item;
  private Date date;
  private BigDecimal amount;
  private Integer userId;
 
  @Id
  public Integer getId() {
    return id;
  }
 
  public void setId(Integer id) {
    this.id = id;
  }
 
  @ManyToOne( targetEntity = com.stevideter.domain.Item.class )
  @JoinColumn(name = "itemid", nullable = false)
  public Item getItem() {
    return item;
  }
 
  public void setItem(Item item) {
    this.item = item;
  }
 
  public Date getDate() {
    return date;
  }
 
  public void setDate(Date date) {
    this.date = date;
  }
 
  public BigDecimal getAmount() {
    return amount;
  }
 
  public void setAmount(BigDecimal amount) {
    this.amount = amount;
  }
 
  public Integer getUserId() {
    return userId;
  }
 
  public void setUserId(Integer userId) {
    this.userId = userId;
  }
 
}

package com.stevideter.domain;
 
public class SelectableItem {
 
  private Integer id;
  private String name;
  private boolean selected;
 
  public Integer getId() {
    return id;
  }
 
  public void setId(Integer id) {
    this.id = id;
  }
 
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public boolean isSelected() {
    return selected;
  }
 
  public void setSelected(boolean selected) {
    this.selected = selected;
  }
}

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
 
<f:view><html><body>
<h:form>
<h:dataTable id="itemsTable" 
    value="#{SelectionBean.selectedItems}" var="item"  >
 
<f:facet name="header">
  <h:outputText value="Items" />
</f:facet> 
<h:column>
  <f:facet name="header">
    <h:outputText value="Select" />
  </f:facet>
  <h:selectBooleanCheckbox value="#{item.selected}" />
</h:column>
<h:column>
  <f:facet name="header">
    <h:outputText value="name" />  
  </f:facet> 
    <h:outputText value="#{item.name}"></h:outputText>
</h:column>
</h:dataTable>
<h:commandButton title="selectItems" 
    value="Select Items"
    actionListener="#{SelectionBean.submitSelections}" />
</h:form>
</body></html></f:view>

package com.stevideter.BackingBean;
 
import java.util.List;
 
import javax.faces.event.ActionEvent;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
 
import com.stevideter.domain.SelectableItem;
import com.stevideter.manager.DomainManager;
 
public class SelectionBean {
 
  private DataModel selectableItems;
  private DomainManager manager;
 
  public void populateSelectableItems(ActionEvent event) {
    selectableItems = new ListDataModel();
    selectableItems.add(manager.getSelectableItems());
  }
 
  public void submitSelections(ActionEvent event) {
    List<SelectableItem> items = (List<SelectableItem>)selectableItems.getWrappedData();
    List<SelectableItem> selectedItems = new ArrayList<SelectableItem>();
    for (SelectableItem item : items) {
      if (item.isSelected()) {
        selectedItems.add(item);
      }
    }
    // do what you need to do with selected items
  }
 
  public DataModel getSelectableItems() {
    return selectableItems;
  }
 
  public void setSelectableItems(DataModel selectableItems) {
    this.selectableItems = selectableItems;
  }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
  <bean id="propertyConfigurer"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location"
      value="file:${catalina.home}/conf/jms.properties" />
  </bean>
 
  <bean id="messageSender"
    class="com.stevideter.spring.jms.MessageSender">
    <property name="jmsTemplate" ref="jmsTemplate" />
  </bean>
 
  <bean id="jmsTemplate"
    class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory"
      ref="userCredentialsConnectionFactory" />
    <property name="defaultDestinationName"
      value="${jms.defaultdestinationname}" />
    <property name="pubSubDomain" value="${jms.istopic}" />
  </bean>
 
  <bean id="userCredentialsConnectionFactory"
    class="org.springframework.jms.connection.UserCredentialsConnectionFactoryAdapter">
    <property name="targetConnectionFactory">
      <ref bean="topicConnectionFactory" />
    </property>
    <property name="username" value="${jms.username}" />
    <property name="password" value="${jms.password}" />
  </bean>
 
  <bean id="topicConnectionFactory"
    class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate" ref="jndiTemplate" />
    <property name="jndiName"
      value="${jms.connectionfactory}" />
  </bean>
 
  <bean id="jndiTemplate"
    class="org.springframework.jndi.JndiTemplate">
    <property name="environment">
      <props>
        <prop key="java.naming.factory.initial">
          com.tibco.tibjms.naming.TibjmsInitialContextFactory
        </prop>
        <prop key="java.naming.provider.url">
          ${jms.jndicontexturl}
        </prop>
      </props>
    </property>
  </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/jee 
       http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
 
           <bean id="propertyConfigurer"
            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                <list>
                    <value>file:${catalina.home}/conf/jms.properties</value>
                    <value>/WEB-INF/jdbc.properties</value>
                </list>
            </property>
        </bean>
 
    <bean id="messageSender"  
             class="com.stevideter.spring.jms.MessageSender">
        <property name="jmsTemplate" ref="jmsTemplate" />
    </bean>
 
    <bean id="jmsTemplate" 
              class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="topicConnectionFactory" />
        <property name="defaultDestinationName">
            <jee:jndi-lookup jndi-name="java:comp/env/jms/eventdestname"/>
        </property>
        <property name="pubSubDomain" value="true" />
    </bean>
 
    <bean id="topicConnectionFactory" 
             class="org.springframework.jndi.JndiObjectFactoryBean">
       <property name="jndiTemplate" ref="jndiTemplate"/>
       <property name="jndiName" value="FTTopicConnectionFactory"/>
    </bean>
 
    <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
           <property name="environment">
                  <props>
                         <prop key="java.naming.factory.initial">
                            com.tibco.tibjms.naming.TibjmsInitialContextFactory
                         </prop>
                         <prop key="java.naming.provider.url">
                            ${jms.jndicontexturl}
                         </prop>
                  </props>
           </property>
    </bean>
</beans>