Nope. Sure can’t. And that sucks. But how do I get my Grails domain objects to pass over web services.

I’m SOOOO happy I finally figured this out. It made our web services almost unreadable and unusable.

Anyway, if you are struggling with this, my solution is to use the XML annotation @XmlAccessorType(XmlAccessType.FIELD) in the domain class. This will limit JAXB’s exploration of the object to only the declared members. Awesome.

(remember to “import javax.xml.bind.annotation.*;”)

Lets suppose you already have experience in your favorite Authentication provider and want to ensure that your webservices use the same users and authentication engine.  For my purposes, Acegi (Spring Security) is that engine.  I’m going to assume we’ll start from where the last post left off, (here’s the zip if you would like to follow along).

So first, install the plugin for Acegi with

grails install-plugin acegi

And then run

grails create-auth-domains

Before we get to far, I want to be sure to setup the Bootstrap so I can be sure that Acegi is doing its job (/grails-app/conf/BootStrap.groovy).

class BootStrap {

     def init = { servletContext ->
    //Protect everything
        new Requestmap(url:"/**",configAttribute:"ROLE_ADMIN").save()
    //Allow a user to login
        new Requestmap(url:"/login/auth**",configAttribute:"IS_AUTHENTICATED_ANONYMOUSLY").save()
    //And have a nice looking login page
        new Requestmap(url:"/images/**",configAttribute:"IS_AUTHENTICATED_ANONYMOUSLY").save()
        new Requestmap(url:"/css/**",configAttribute:"IS_AUTHENTICATED_ANONYMOUSLY").save()
    //Our Webservices can be seen publicly, but require an authentication header
      new Requestmap(url:"/ws/**",configAttribute:"IS_AUTHENTICATED_ANONYMOUSLY").save()

      //Credentials Information
      def pass = DU.shaHex("passw0rd")

    //Create some users
      def person1 = new Person(username:"user1", userRealName:"user", passwd:pass, email:"admin@site.com",emailShow:true, enabled:true, description:"a user")
        def person2 = new Person(username:"user2", userRealName:"user two", passwd:pass, email:"user@user.com",emailShow:true, enabled:true, description:"user")

        def clientAuth = new Authority(description:"Users",authority:"ROLE_USER")
                                        .addToPeople(person1)
                                        .addToPeople(person2)
                                        .save()
     }
     def destroy = {
     }
}

This will give us users and permissions when we run.

Alright, nothing too intense yet.  But now we have to worry about securing our CXF web services with Acegi as an authentication provider.  The first step involves getting dirty in the Spring xml config again.  We need to add some in interceptors to the server.  Pretty straight forward if you know what you are doing (I still don’t understand it great). Edit /web-app/WEB-INF/cxf-servlet.xml to look like the following:

<?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:simple="http://cxf.apache.org/simple"
    xmlns:soap="http://cxf.apache.org/bindings/soap"
    xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://cxf.apache.org/bindings/soap

http://cxf.apache.org/schemas/configuration/soap.xsd

http://cxf.apache.org/simple

http://cxf.apache.org/schemas/simple.xsd">
    <!--create CXF service-->
    <simple:server id="samplePublishedService" serviceClass="com.domain.services.Sample" address="/sample">
        <simple:serviceBean>
          <bean class="SampleService" />
        </simple:serviceBean>
        <simple:inInterceptors>
          <bean class="org.apache.cxf.binding.soap.saaj.SAAJInInterceptor"/>
          <bean class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
            <constructor-arg>
                <map>
                       <entry key="action" value="UsernameToken"/>
                       <entry key="passwordType" value="PasswordText"/>
                       <entry key="passwordCallbackRef">
                          <bean class="com.domain.security.PasswordHandler"/>
                       </entry>
                   </map>
            </constructor-arg>
            </bean>
          <bean class="com.domain.security.ValidateUserTokenInterceptor" />
        </simple:inInterceptors>
    </simple:server>
</beans>

I just referenced a couple classes that don’t exist, so I get you know whats next.  Add those classes to /src/groovy/ with the following code:

PasswordHandler.groovy

package com.domain.security;

import java.io.IOException;

import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.UnsupportedCallbackException;
import org.codehaus.groovy.grails.commons.GrailsApplication;
import org.codehaus.groovy.grails.plugins.springsecurity.GrailsDaoAuthenticationProvider;
import org.springframework.security.AuthenticationManager;
import org.springframework.context.ApplicationContext;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;

import org.apache.ws.security.WSPasswordCallback;
/**
 * This is passed to the WSS4JInHandler in the server configuration.
 *
 * @author bowlinguru based on XFire implementation by Michael Vorburger, based on XFire sample by <a href="mailto:tsztelak@gmail.com">Tomasz Sztelak</a>
 */
public class PasswordHandler implements CallbackHandler {

    public PasswordHandler() {
    }

    public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {

        // There is nothing we could actually do here...

        WSPasswordCallback pc = (WSPasswordCallback) callbacks[0];
        String uid = pc.getIdentifer();
        System.out.println(uid);
        System.out.println(pc.getPassword());
        // No pc.setPassword(password); - we don't have a pwd (and don't need one)
    }
}

ValidateUserTokenInterceptor.groovy

package com.stewie.security

import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.apache.cxf.message.*;
import org.apache.cxf.interceptor.Fault;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
import org.springframework.security.AuthenticationManager;
import org.apache.ws.security.WSConstants;
import org.apache.ws.security.WSSecurityEngineResult;
import org.apache.ws.security.WSUsernameTokenPrincipal;
import org.apache.ws.security.handler.WSHandlerConstants;
import org.apache.ws.security.handler.WSHandlerResult;
import org.codehaus.groovy.grails.plugins.springsecurity.GrailsDaoAuthenticationProvider;
import org.springframework.security.AuthenticationManager;
import org.springframework.context.ApplicationContext;

class ValidateUserTokenInterceptor extends AbstractPhaseInterceptor {
    public ValidateUserTokenInterceptor(){
        super(Phase.UNMARSHAL);
    }
    public ValidateUserTokenInterceptor(java.lang.String phase){
        super(Phase.UNMARSHAL);
    }
    public ValidateUserTokenInterceptor(java.lang.String phase, boolean uniqueId){
        super(Phase.UNMARSHAL);
    }
    public ValidateUserTokenInterceptor(java.lang.String i, java.lang.String p){
        super(Phase.UNMARSHAL);
    }
    public ValidateUserTokenInterceptor(java.lang.String i, java.lang.String p, boolean uniqueId){
        super(Phase.UNMARSHAL);
    }
    void handleMessage(Message message) throws Fault{
        println message
        Vector result = (Vector) message.getContextualProperty(WSHandlerConstants.RECV_RESULTS);
        if (result==null) {
            throw new IllegalArgumentException(WSHandlerConstants.RECV_RESULTS + " Property not found in MessageContext?!");
        }
        for (int i = 0; i < result.size(); i++) {
            WSHandlerResult res = (WSHandlerResult) result.get(i);
            for (int j = 0; j < res.getResults().size(); j++) {
                WSSecurityEngineResult secRes = (WSSecurityEngineResult) res.getResults().get(j);
                int action = secRes.getAction();

                // USER TOKEN
                if ((action & WSConstants.UT) > 0) {
                    WSUsernameTokenPrincipal principal = (WSUsernameTokenPrincipal) secRes.getPrincipal();
                    // "Set user property to user from UT to allow response encryption" (probably not needed at this point at Visana)
                    //context.setProperty(WSHandlerConstants.ENCRYPTION_USER, principal.getName());

                    org.codehaus.groovy.grails.commons.GrailsApplication dga = org.codehaus.groovy.grails.commons.ApplicationHolder.getApplication();
                    //grails.spring.BeanBuilder bb = new grails.spring.BeanBuilder();
                    ApplicationContext appContext = dga.getMainContext();//bb.createApplicationContext();
                    appContext.getBeanDefinitionNames().each{println it};
                    def sessionFactory = appContext.getBean("sessionFactory");
                    //Make sure we have a session
                    def session = sessionFactory.openSession();
                    get the authenticationManager
                    AuthenticationManager manager = (AuthenticationManager)appContext.getBean("authenticationManager");
                    // Set the Acegi Security Context
                    SecurityContextHolder.getContext().setAuthentication(
                                    manager.authenticate(new UsernamePasswordAuthenticationToken(principal.getName(),principal.getPassword())));
                }
            }
        }
    }
}

Now we call the PasswordHandler, which makes sure there is a username and password, and then the authenticator, which calls our Acegi to create the session.  We can get the user principal from the same way we would if it was a manual (webpage) log-in.

The beauty of this solution is that security is all handled discretely.  All a user needs to do is call the web method with their SOAP envelope with an authentication header.

Here is a sample soap envelope (I use soapUI to test):

POST http://localhost:8080/testApp/ws/sample HTTP/1.1
Content-Type: text/xml;charset=UTF-8
SOAPAction: ""
User-Agent: Jakarta Commons-HttpClient/3.1
Host: localhost:8080
Content-Length: 892

<soapenv:Envelope xmlns:ser="http://services.domain.com/" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
   <soapenv:Header><wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"><wsse:UsernameToken wsu:Id="UsernameToken-14535355" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"><wsse:Username>user1</wsse:Username><wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">passw0rd</wsse:Password><wsse:Nonce>083LNLHB9OW2YKc85/TbhA==</wsse:Nonce><wsu:Created>2009-07-07T15:03:26.218Z</wsu:Created></wsse:UsernameToken></wsse:Security></soapenv:Header>
   <soapenv:Body>
      <ser:methOne>
         <ser:arg0>0</ser:arg0>
         <ser:arg1>"whit"</ser:arg1>
      </ser:methOne>
   </soapenv:Body>
</soapenv:Envelope>

Final source here

Grails and Xfire

I was assigned to figure out how to do the top level exposing of our methods, while my teammates were working on consuming from the other service.  It was easy enough to get to work.  The Xfire plugin works quite simply.  Just install, add expose = true, and your exposing your webservices.  To everyone.  With no security.  To add security, add a couple of Spring transactional layers (wow, I trivialized, but its not easy at all when you don’t have Spring experience).  All was good, every thing was working the way I wanted.  I was interacting with Xfire and securing with Acegi.

Then we merged our branches.  My stuff broke the consuming part (done with jaxws, not sure how, I didn’t do it).

What on earth?  Why won’t this work together?

Xfire is using jaxws too.  Oh, but its a different version.  And its REALLY old.  Development on Xfire stopped before Grails was born.  Why the hell is there a plugin that uses such out of date code?  Damnit.  And there’s no simple upgrade from the Grails Xfire plugin to Apache CXF (it’s replacement).  Oh well, throw all this work out and start over.

Grails and CXF

CXF is a completely different beast in terms of what I have to do to get it to work with Grails.  No simple “grails install-plugin”.   No “add one line to expose”.  No good (Grails and CXF) tutorial.  Nobody doing what I’m trying to do.  (Well, I guess there is someone trying to do it because I find plenty of questions, similar stack traces, and a bunch of hints on where to go, but none of it was assembled together)  Hopefully, my experience can help others, and maybe someone who knows a little more about Spring, Grails, or CXF will be able to improve this solution.

Before we get too far, this solution is VERY touchy.  It requires you to recompile everytime you make a change to the source.  It gives horrible stack traces (but you’re used to that if you’re using grails).  Use it at your own risk.

First grab the jars from the CXF Apache site. There are a bunch of jars, and I don’t really know which ones are needed and which ones are not, but I found the following list and it works.  Examine WHICH_JARS if you want to be sure it works.

asm-2.2.3.jar
commons-lang-2.4.jar
commons-logging-1.1.1.jar
cxf-2.2.2.jar
cxf-manifest.jar
FastInfoset-1.2.3.jar
geronimo-activation_1.1_spec-1.0.2.jar
geronimo-annotation_1.0_spec-1.1.1.jar
geronimo-javamail_1.4_spec-1.6.jar
geronimo-jaxws_2.1_spec-1.0.jar
geronimo-jms_1.1_spec-1.1.1.jar
geronimo-servlet_2.5_spec-1.2.jar
geronimo-stax-api_1.0_spec-1.0.1.jar
geronimo-ws-metadata_2.0_spec-1.1.2.jar
jaxb-api-2.1.jar
jaxb-impl-2.1.9.jar
jaxb-xjc-2.1.9.jar
jaxen-1.1.jar
jaxws-2_1-mrel2-api.jar
jaxws-rt-2.0EA3.jar
jetty-6.1.18.jar
jetty-util-6.1.18.jar
jsr181-api.jar
neethi-2.0.4.jar
saaj-api-1.3.jar
saaj-impl-1.3.2.jar
saaj-impl-1.3.jar
velocity-1.5.jar
wsdl4j-1.6.2.jar
wss4j-1.5.7.jar
wstx-asl-3.2.8.jar
xml-resolver-1.2.jar
XmlSchema-1.4.5.jar

Once the jars are in the lib folder, an interface for the exposed class needs to be made in the /src/groovy.

package com.domain.services;

import com.domain.*;

interface Sample{
    int methOne(int arg1, String arg2)
}

Then the interface needs to be implemented by a service (well, it doesn’t have to be a service, just the class you want to expose).

import com.domain.*;

class SampleService implements com.domain.services.Sample {
    boolean transactional = true

    int methOne( int arg1, String arg2){

          return 3;

    }

Now we have the service all ready to expose, and we just need to tell Spring to do it.  We can do this with some xml in the right places.  In order to be able to find where I added the XML (so when I need to add another service interface) I created cxf-servlet.xml (don’t try to rename it. It won’t work) in web-app/WEB-INF with the following content:

<?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:simple="http://cxf.apache.org/simple"
    xmlns:soap="http://cxf.apache.org/bindings/soap"
    xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://cxf.apache.org/bindings/soap

http://cxf.apache.org/schemas/configuration/soap.xsd

http://cxf.apache.org/simple

http://cxf.apache.org/schemas/simple.xsd">
    <!--create CXF service-->
    <simple:server id="samplePublishedService"
                   serviceClass="com.domain.services.Sample"
                   address="/sample">
        <simple:serviceBean>
          <bean class="SampleService" />
        </simple:serviceBean>
    </simple:server>
</beans>

This will setup the basic servlet, but doesn’t put it any where.  If desired, “address” can be a complete URL, with a different port number, and your app would serve this service there. (i.e. address=”http://localhost:523/services” would allow your SOAP calls over port 523)  However, I want to aggregate my services so a user can find the wsdl for any of my services easily.

Next, if you haven’t already, run

grails install-templates

This will create /src/templates/war/web.xml.  Add the following to that file (inside the <web-app> tags):

<servlet>
        <servlet-name>CXFServlet</servlet-name>
        <display-name>CXF Servlet</display-name>
        <servlet-class>
            org.apache.cxf.transport.servlet.CXFServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>CXFServlet</servlet-name>
        <url-pattern>/ws/*</url-pattern>
    </servlet-mapping>

Then to /grails-app/conf/spring/resources.xml (or rewrite this to match the .groovy way) add

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:simple="http://cxf.apache.org/simple"
    xmlns:lang="http://www.springframework.org/schema/lang"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd
http://cxf.apache.org/simple http://cxf.apache.org/schemas/simple.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
    <import resource="classpath:WEB-INF/cxf-servlet.xml" />
</beans>

At this point, you should be able to run.  (You probably have to run with -Ddisable.auto.recompile=true.  Also “grails clean”ing helps solve some of the errors.) So that is where I will end.  I will post soon about Acegi integration.

Point your browser to “http://localhost:8080/testApp/ws/” (for example) to see the list of services. Links will give the wsdls.

Here is a copy of the source.

I spent the last week on the True Pike Challenge, a specialized course through Boulder Outdoor Survival School for 20 Pi Kappa Alpha brothers.  We spent a week in the Utah desert; hiking for miles, eating little food, and pushing our limits in ways I could hardly imagine before I arrived.  The nights were as cold as the day was hot. A strong brotherhood was forged while cuddling for warmth during the wee hours of the morning.  The rain came as we were moving,  but stopped when we made camp.  After a night alone, our journey to find eachother found hail crushing our spirits.  None of us were successfull at making fire, so many dinners were wasted and we were left hungry.  We covered nearly fourty miles and a 4000 foot elevation change in five days of hiking.  Last week was the most miserable week of my life.

But that makes this week awesome.

One of the philosphies of BOSS is to compare down.  All week we told ourselves we could be naked, sleeping on dirt, with sunburns on top of our blisters.  It made the week more managable. It helped us humble ourselves.

My week in Utah gave me a low to compare the rest of my life to.  It pushed my limits, and showed me how far beyond them I could go.

I don’t like to use cheese because there are already a lot of flavors going on. Also, when normally making guacamole, I would add salt and lime juice, but these burgers already have enough salt and I used all of my batch of guacamole (the main purpose of the lime juice is to preserve the green color the guac).

I’d like take a few moments to congratulate Jay and Laura on their marriage, but first, for those who do not know me, I’m Alex, Jay’s Brother, and until a few hours ago, the only person here, other than Jay, with “Weingarten” for a last name. I am absolutely honored to be the first to toast Jay and Laura here today because, after all these years, Jay has finally admitted that I am the best man

I’d like to thank Mr and Mrs Foley for coordinating such a wonderful reception, and for providing my brother the love of his life. I can remember when Jay and Laura met.  Nights when we would hang out together bullshitting about sports or video games, or whatever, quickly deteriorated to him locked in his room on the phone with some mystery woman.  Then I met her.  It was the night of his prom, so she was all dolled up looking almost as beautiful as she does now.  And I understood why he didn’t care about watching sports or playing video games with me any more.

It’s always been a little hard to be Jay’s little brother.  He left some huge shoes to fill. And I’ve tried my hardest to fill them, but if I am able to be half as lucky with love as he has been and find a wife half as amazing as Laura, I will consider myself blessed.  So let us raise our glasses to Jay and Laura, may love permeate their souls, and bind them together in eternal happiness.

I took a lot of pic with Dan’s camera, most of which are uploaded to my photo site.  If you have any photos, let me know so I can get you a log in so you can upload them and to share them with everyone else!

The biggest obstacle in connecting to Google with Grails was the lack of a good resource.  I even struggled to find a good Java resource, so I knew there was no way Grails had one.

There are two parts essential to connecting to Google Calendar.  First, you need to create a connection to google using one of their APIs.  The two available are OAuth and AuthSub.  Because of the nature of how we want users connecting to Google, I choose to use AuthSub (and because it seemed to have more reasources).   The second part of the integration is using the CalendarService API.  This is fairly straight forward after getting the authentication piece working.

Getting Started

With grails, the easiest way to get any of Google’s data services is to install the google-data plugin

grails install-plugin google-data

This installs several jars that are the Java adaptation of the Google Data API.  The JavaDocs can be found here.

AuthSub

The AuthSub is pretty well documented.  I’m just going to throw out some code, and if you can’t understand it, ask.

First the Imports:

import com.google.gdata.client.*;
import com.google.gdata.client.calendar.*;
import com.google.gdata.data.*;
import com.google.gdata.data.acl.*;
import com.google.gdata.data.calendar.*;
import com.google.gdata.data.extensions.*;
import com.google.gdata.util.*;
import com.google.gdata.client.http.AuthSubUtil;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

Now some AuthSub Code:

    //This will return a URL.  The user will have to be redirect()ed to it to get the security token
     def sendRequestURL() {
        //we don't have access for one reason or another. So re-up with google.
	String nextUrl = "http://localhost:8080/returnHandler";
	String scope = "http://www.google.com/calendar/feeds/";
	boolean secure = false;  // set secure=true to request AuthSub tokens
	boolean session = true;

	String authSubUrl = AuthSubUtil.getRequestUrl(nextUrl, scope, secure, session);
	return authSubUrl;
    }

    def returnHandler = {
    	if (params.token){
    		session['googleToken'] = getSessionToken(params.token)
	}
	redirect(action:"weHaveApproval")
    }

    //getting a session token will allow us to interact for a while
    def getSessionToken(token) {
    	return AuthSubUtil.exchangeForSessionToken(token, null);
    }

Basically, installing the plugin did all the legwork of us. We just have to assemble how to handle our situation.

Google Services

Again, the installed plugin will handle most of the work, and it is well documented.  I again will just give code, and let you experiment.

Here are couple of methods for creating a calendar and creating events for that calendar:

    def calendarUser = {
	//create the service
    	CalendarService service = new CalendarService("evodox-appointmentsDemo-v1.0");
	service.setAuthSubToken(googleToken, null);

	//Find the proper calendar
	CalendarFeed resultFeed = service.getFeed(owncalendarsFeedUrl, CalendarFeed.class);
	def calendar;
	resultFeed.getEntries().each {
		println it.getTitle().getPlainText()
		if (it.getTitle().getPlainText() == calName){
			println "matched calName"
			calendar = it;
		}
	}
	//see if we found the calendar. if not, make it.
	if (!calendar){
		calendar = createCalendar(service, calName);
	}
	//Add an event to that calendar
	jobList.each{
		if (it.nextContact > new Date()){
	  			calendar = addJobAppointment(calendar,service,it);
		}
	}
    }

    private static CalendarEntry createCalendar(CalendarService service, String title) throws IOException, ServiceException {
      // Create the calendar
      CalendarEntry calendar = new CalendarEntry();
      calendar.setTitle(new PlainTextConstruct(title));
      calendar.setSummary(new PlainTextConstruct("This calendar contains you appointments made in Evodox."));
      calendar.setHidden(HiddenProperty.FALSE);
      calendar.setColor(new ColorProperty(GREEN));

      // Insert the calendar
      return service.insert(owncalendarsFeedUrl, calendar);
    }

    private static CalendarEntry addJobAppointment(CalendarEntry calendar,CalendarService service, job) throws IOException, ServiceException {
      def list = calendar.getEditLink().getHref().split("/")
      URL postURL = new URL("http://www.google.com/calendar/feeds/" + list[list.length-1].replace("%40","@") + "/private/full");

      CalendarEventEntry myEvent = new CalendarEventEntry();
      myEvent.setTitle(new PlainTextConstruct(job.contact.toString() + " - " + job.nextAction));
      myEvent.setContent(new PlainTextConstruct("Event in evodox:n" + job.contact.toString() + " - " + job.nextAction));
      def googleFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
      DateTime startTime = DateTime.parseDateTime(googleFormat.format(job.nextContact)+ "-05:00")//DateTime.parseDateTime("2009-05-19T15:00:00-08:00");
      DateTime endTime = DateTime.parseDateTime(googleFormat.format(job.nextContact)+ "-05:00") //DateTime.parseDateTime("2009-05-19T17:00:00-08:00");
      When eventTimes = new When();
      eventTimes.setStartTime(startTime);
      eventTimes.setEndTime(endTime);
      myEvent.addTime(eventTimes);

      CalendarEventEntry insertedEntry = service.insert(postURL, myEvent);
      return calendar.update();

}

Of course , these aren’t perfect solutions, but they wil help you get started with interacting with Google Calendar, and probably some other services.

Resources:

• Google’s Java Tutorial
• Google Data Java Client Home
• Google Data Java Client Javadoc

Last night I made a recipe I first made in my high school foods class.  It is a sandwich that the teacher referred to as something Monte Cristo.  I will henceforth call it “The Bake of Monte Cristo”, because its fun to say.   The recipe is so easy that, after the first time I made it, it just comes back to me every time I want to make it.

Ingredients:

2 tubes of 8 Crescent Rolls
1 Tbl. butter
1 Tbl. honey
8 oz Deli sliced Ham
8 oz. Deli sliced Turkey
4 oz Munster Cheese
2 Tbl. Raspberry Perserves
Sesame Seeds (optional)

Required Materials:

2 baking sheets or 13×9 pans
Sauce bowl
Brush (optional)

Bread Prep:

1. Open and unroll the Crescent Rolls.  Each roll comes as 2 rolls of 4 triangles.  Keep them like this.  Press the seems together, so that from the 2 tubes, you make 4 rectanglur pieces.  Place on 2 baking sheets
2. Melt the butter and honey together in the microwave.  Don’t worry about being exact with 1 Tbl. of each, just get close to even amounts.
3. Brush (or use your fingers to spread) the melted honey-butter over the 4 crescent roll pieces (just the ‘up’ side)
4. Bake for 10 minutes at 325°F, or until golden brown.

Sandwich Assembly:

1. Create the sandwich on a baking pan as follows:

Bread
Raspberry Perserves
Bread
Munster Cheese
Ham
Bread
Turkey
Bread

2. Top with a drizzle of honey and ornamentation of sesame seeds.
3. Bake at 325°F until warm throughout.  (You can tell when the Munster  is all melty)

Enjoy!

Well, there it is finally.  My first somewhat good post.  I’d love to hear from anyone subscribed or anyone who follows the recipe!