So, I thought it would be fun to create a screencast with some tips for getting started building APIs with Grails! The screencast covers content types, API URL mappings, customizing JSON output with marshallers and even Rob Fletcher’s GSON plugin. I unfortunately recorded this screencast on a MacBookPro as opposed to an iMac and there’s some background noise because of the MBP fan. First and last time I use a MBP for a screencast, ha! Hopefully it doesn’t distract from the content too much. Thanks for watching!

The sample app built in the screencast is located on GitHub.

This isn’t just a regular hackathon though as it will instead be a competition with Target gift card prizes for the top GR8 hackers! The competition will be focused on two categories with $2,400 in total gift card prizes (1st place: $500, 2nd place: $400, 3rd place: $300 in each category). The official contest rules for how the entries will be judged will be published closer to the event. Here is a quick overview of the two categories though:

1. The first category is a bug race on the various open-source GR8 technologies. There will be various points awarded for the types of bugs found, solutions identified, pull requests opened and of course commits made! The judging for this category will be very quantitative and the winners will simply be the ones that get the most points.
2. The second category will focus on utilizing Target APIs with GR8 technologies. This event will mark the first alpha release of public Target APIs and we are excited to gather feedback from the GR8 developer community! These APIs are used by various applications at Target today. The judging for this category will be qualitative and the Target API team will select the winners based on creativity, APIs used and potential relevance to Target guests.

Target will be providing appetizers and refreshments for participants throughout the hackathon as well as have representation from various Target teams if anybody is interested in learning more about technology opportunities at Target.

Target is very excited to be a sponsor of GR8CONF US for 2013 and to host this hackathon as part of the conference for attendees! I look forward to providing you more details about the hackathon as we get closer to the event. I also will publish an official registration form soon! I hope that as many conference attendees as possible plan to attend and hack at the GR8CONF US hackathon!

Disclaimer: You must be registered as a conference attendee before Wednesday, July 17th at 5pm CST to be able to enter Target Plaza Commons for the event. There will be no exceptions. As per Target policy, all attendee names need to be known before the event. Target employees are welcome to participate in the hackathon, but are not eligible to win the gift cards. All participants will need to fill out the registration form and agree to the contest rules. The contest for gift cards starts and ends with the hackathon: July 21st from 6:00pm to 10:00pm.

• grails-core update for GRAILS-9052
• grails-data-mapping simple update for spring-data-mongo library
• grails-doc sipmle update for Java EE Containers

Thanks to everyone that came to my talk and it was great seeing so many people from the Groovy community at the conference!

GR8CONF Contributing Back to Grails Presentation (Keynote)

GR8CONF Contributing Back to Grails Presentation (SlideShare – screencasts don’t work)

The key to implementing PJAX is that you need to have a “chrome-less” view for PJAX requests. This means the view can’t have the main.gsp layout applied to it (or whatever your layout is called). There are a number of different ways you could do this. First, you could simply look for the HTTP header that PJAX adds to each request called X-Pjax and then apply a different layout in the controller (or no layout at all). The approach I decided to take was a little different though. I decided that I didn’t want to modify any controllers and instead do it at the framework level. I also didn’t want to modify any views that already have the meta.layout (<meta name=”layout” content=”main”/>). My solution was to extend GrailsLayoutDecoratorMapper with my own new class called PjaxDecoratorMapper. I was originally going to create a Grails PJAX plugin to take care of this, but you need to modify sitemesh.xml in order to register this new decorator and I don’t believe there currently is any programmatic way to do that (like you can with web.xml). Also, the way that I’m implementing PJAX is certainly not the only way in a Grails app so I’m not sure how much value a plugin would even really provide. If people like this approach and it provides value, I’m certainly open to creating a plugin though. Let me know! So, let’s dive in!

First, we need to get the PJAX JavaScript:

• grails create-app pjaxsample
• cd pjaxsample/web-app/js
• curl -O https://raw.github.com/defunkt/jquery-pjax/master/jquery.pjax.js

Edit grails-app/conf/ApplicationResources.groovy to look like the following:

Next, we need to create a layout that will only be used for our PJAX requests.

Create a new grails-app/views/layouts/pjax.gsp that looks like this:

As you can see, all this layout is doing is rendering the body wrapped in a div called main. You can obviously call this div whatever you want or have multiple layouts for different divs that you want to use PJAX with if needed. For my needs, I simply wanted to always update one common area with PJAX, so just using one div for this met my needs.

Now let’s create our new decorator and configure it with sitemesh!

Create a new src/groovy/grails/pjax/PjaxDecoratorMapper.groovy file that looks like this:
Then modify the decorator-mappers part of web-app/WEB-INF/sitemesh.xml so it looks like this:

As you can see in the Groovy code, all it’s doing is adding a new check for the X-Pjax header and using the pjax.gsp layout if it finds it. Then in sitemesh.xml, we are setting our new class to be the decorator instead of the default one. This is the key to not having to modify any existing controllers or views since this check is happening at the framework level as opposed to in app code. With this stuff in place, now we are ready to use some PJAX! I decided to take the first approach outlined on the PJAX README by using a data attribute on any links I’d like PJAX-ified and then including this JavaScript in web-app/js/application.js. You certainly don’t have to use this approach though and can play with the other ones if you’d like!

In the screencast below, I will now demonstrate using this PJAX setup in a sample application! You can download all the source for this screencast on GitHub: https://github.com/gr8casts/pjaxsample.

I hope you enjoyed this post about using PJAX in Grails! Please let me know in the comments if you have any suggestions for ways to improve PJAX usage in Grails and if you found this valuable or not. Thanks for reading & watching!

Back in December, I wrote a couple posts about using Stripe with Grails to process credit cards and released some initial milestones for a plugin. Then last week, I released version 1.0 of the plugin. So, today I’m just providing a screencast to go along with that 1.0 release! Please let me know in the comments if you find the screencast valuable or not!

Yes, my API keys shown in the video have been invalidated.

The source-code for this screencast is available on GitHub: https://github.com/bobbywarner/grails-coffeescript-demo2

This screencast was inspired by Ryan Bates’ RailsCasts Episode #147. I borrowed some of his excellent CoffeeScript example code.

The source-code for this screencast is available on GitHub: https://github.com/bobbywarner/grails-coffeescript-demo

This screencast was inspired by Ryan Bates’ RailsCasts Episode #114. I borrowed some of his excellent CoffeeScript example code.

The topic is “Jumping into Grails 2.0″ using the spring-security-core and resources plugins as well as some unit testing. Please let me know in the comments if you find the screen-cast valuable or not.

As of the 1.0.M6 release, the plugin has a new tag library that takes care of all the JavaScript and credit card input fields for you! This is all that’s required now to create the form:

A couple notes about this code compared to my previous post’s code:

• You no longer need to declare the resource module stripe, the plugin takes care of this.
• You no longer need to worry about setting the publishableKey, the plugin takes care of this now too.
• <stripe:script formName=”payment-form”/> is required to setup all the JavaScript. The formName attribute needs to match the name attribute on your <g:form> tag.
• <stripe:creditCardInputs cssClass=”form-row”/> is optional if you want the plugin to create the credit card fields (number, cvc, exp-month & exp-year). The cssClass attribute is what class you want the plugin to put for the div tag surrounding each credit card field. You don’t have to use this though and can include these fields manually in your form if you’d prefer.

This will all be covered in the plugin documentation which will be done with the 1.0 final release. Thanks to those who already provided feedback! Please let me know what you think of these new updates as well as any other features you’d like included!

Also, a quick note that I forgot to mention about Stripe in my last post is that you can accept payments from any country (Visa, MasterCard, American Express, Discover, JCB, and Diners Club cards) and customers can use pretty much any currency, but you currently have to be based in the US to receive payments. Sounds like they are working to expand to other countries though. Check out their FAQ for more information.

First, you will need a sample Grails 2.0 application. You could certainly use Grails 1.3.7 too as there’s nothing limiting the plugin to 2.0, but it does require the resources plugin and I just figure most new Grails apps will be 2.0.


grails create-app stripesample
cd stripesample
grails install-plugin stripe
grails create-controller checkout


We will need to set two configuration items in Config.groovy. Before we can add these though, we need to register for a Stripe account. So, head on over to Stripe and create your account. Once you’re logged in, click on the top-right link for Your Account and then Account Settings. This will pop open a box where you can find your API Keys. Stripe provides each account with separate publishable and secret keys for testing and live. We only care about the testing ones for now. Let’s add these two values to our sample application’s config file:

stripesample/grails-app/Config.groovy

grails.plugins.stripe.secretKey = 'YOUR_TEST_SECRET_KEY'
grails.plugins.stripe.publishableKey = 'YOUR_TEST_PUBLISHABLE_KEY'


You will obviously want to put these config values in the appropriate environment in Config.groovy. The plugin takes care of setting the secret key for you in the Stripe abstract class and the publishable key will be set from our JavaScript which we’ll cover in a bit.

Next we need to include the JavaScript library provided by Stripe. The plugin exposes this library as a standard resource module called stripe. So, you need to include this in your resource modules declaration. Make sure you use modules (plural) if you have more than one as opposed to module (singular).


<r:require modules="application, stripe"/>

or

<r:require module="stripe"/>


The way Stripe works is that it uses JavaScript to capture the credit card details and creates a token. So, the credit card details never actually hit the server which makes it really easy to be PCI compliant. The JavaScript then creates a hidden field on the form with the token as the value and submits the form to the server. Once on the server, we will use Groovy to capture the amount from the form, the token and create a Stripe Charge. Piece of cake!

Create a new file called index.gsp in stripesample/grails-app/views/checkout and put the following for the contents of the file:

Next we need to modify the CheckoutController we created. Put the following for the contents of this file:

And finally, we need to create a simple confirmation.gsp in stripesample/grails-app/views/checkout and put the following for the contents of the file:

This is obviously a really simple example and can be improved greatly with styling, validation, flash message, etc, but I did this on purpose just to keep it really simple. A couple things to notice in the sample code:

1. The JavaScript is pulling in your publishable key from Config.groovy
2. The JavaScript then takes the credit-card details and creates a token and inserts this into a hidden-field on the form
3. The server never sees the credit-card details, only the token created by the Stripe JavaScript library and the amount to charge

Let’s try it out! Here are some sample values that will work for testing:

• Credit Card Number: 4242424242424242
• CVC: 123
• Expiration Month: 12
• Expiration Year: 2015

You can use whatever you want for the amount. Enter it as you normally would in dollars like 12.99 for example. The controller converts this to an integer of cents since Stripe deals in cents. If goes well, you should see the confirmation page with the success message! If something goes wrong and you receive the error message, you can comment out the try/catch block around the Charge.create(chargeParams) to see the actual error message from the Stripe API. Once you have successfully submitted the form and received the confirmation message, go to your Stripe account and click on Payments to verify that it shows up!

This post is just barely touching the surface of the Stripe capabilities! We did a one-time charge here, but you can do all sorts of stuff with the Stripe API with Groovy like subscriptions / plans for recurring payments. You can also do standard stuff like issue refunds or coupons. Take a look at the Java API documentation for more details.

Well that concludes my walk-through of using Stripe for processing credit cards in a Grails application. I hope you found this post interesting and consider trying out my plugin! Here are links to the source for the plugin and the plugin portal page.

• https://github.com/bobbywarner/grails-stripe
• http://grails.org/plugin/stripe