So far so good, but I did have a few issues getting started with Grails dev.

When loading up for the first time I seemingly had no support for Groovy or Grails which was disappointing. To solve this issue:

1. Add http://dist.codehaus.org/groovy/distributions/greclipse/snapshot/e3.5/ to your available software sites
2. Select Help > Install New Software, Select the SpringSource Update Site. Under Extensions / STS you’ll see an option for SpringSource Tool Suite Grails Support. Tick that at the top level and click next, proceed to accepting licenses and some background magic will happen for you.
3. Restart STS

You should now be up and running, i’ll be having more of a play and making another post in the future about how I’ve found it.

NB: Failing to do step 1 correctly will result in the following when doing step 2:

Cannot complete the install because one or more required items could not be found.
Software being installed: SpringSource Tool Suite Grails Support 2.2.0.200910210131-RELEASE (com.springsource.sts.grails.feature.group 2.2.0.200910210131-RELEASE)
Missing requirement: SpringSource 2.2.0.200910210131-RELEASE (com.springsource.sts.grails.ui 2.2.0.200910210131-RELEASE) requires ‘bundle org.codehaus.groovy.eclipse.core 2.0.0′ but it could not be found
Cannot satisfy dependency:
From: SpringSource Tool Suite Grails Support 2.2.0.200910210131-RELEASE (com.springsource.sts.grails.feature.group 2.2.0.200910210131-RELEASE)
To: com.springsource.sts.grails.ui [2.2.0.200910210131-RELEASE]

You can find more of these at http://v1kram.posterous.com/liu-bolinthe-invisible-man/?

This is a pretty good way to help folks understand that on the web, what you can see is really only part of the picture. Often the hidden technologies, processes and standards will play the most important role in your success online. Thus it really is critical to work with someone who understands the entire environment.

This blog will feature a range of content mostly focusing on various technologies we are working with. If you’d like to keep updated we have a handy RSS feed for you to subscribe to.

Thanks for stopping by, if you’d like to provide any feedback feel free to send it to us via email at gday@intient.com

What we’d done in the case of our domain objects User, Group and Role is to use the static mapping feature of GORM to set the table names as _user, _group and _role respectively. The reason for this was simply to avoid conflicts with reserved words in MySQL, Oracle and so on.

At first thought making the name configurable sounded easy enough but the static nature of the mappings block did throw in a little added complexity. Eventually we settled on the following solution:

Add a config option to your grails application for each table name you wish to make configurable.

In your domain class add:

import org.codehaus.groovy.grails.commons.ConfigurationHolder

and create a static variable as such:

class User {
    static config = ConfigurationHolder.config

Now in your mapping block simply add:

table User.config.grails.tablenames.user

Easy! Now users can modify the table names generated by GORM (well Hibernate but lets say GORM ).

As part of this we’ll no longer be maintaining GConnect as a product. Below we’ve provided a number of answers to common questions our customers might have, if you have any additional questions please contact Intient sales in the first instance.

The really good news is that GConnect is now fully open source so you’ll be able to continue to use the product well into the future!.

Q: I’ve had a license for a while will you still offer support?
A: Absolutely. We will continue to provide expert, timely support for all GConnect customers while your support period is valid.

Q: How can I tell when my support period expires?
A: The license.xml file in your GConnect config directory will have a date located in the <expires> </expires> block. This is the date when support will expire.

Q: Will the software continue to operate after the expiry date?
A: Yes, GConnect was designed to not stop operating even if there was no support contract valid.

Q: What if we need commercial support after expiry?
A: Intient will continue to offer commercial support for the Open Source version of GConnect on a case by case basis. A typical support query will be answered for $200 USD, we’ll provide quotes in more complex cases.

Q: Open source version of GConnect?
A: Yes!. We honestly want only the best for all our customers so to ensure you can continue to build on your GConnect deployment we’ve made sure everything that was previously commercial in nature is now available as open source at http://github.com/intient/gconnect From here you can continue to use GConnect well into the future adding any features or making any change you might desire. There is no limits of any kind for this version.

Q: I’ve recently purchased or renewed my GConnect license what options do I have?.
A: You have two options in this instance. Continue to use the software and we’ll continue to support you until your support period is complete or at our discretion and on a case by case basis we’ll provide customers with refunds. Please contact us if you’d like to discuss this.

Q: You guys had started work on a new version will this be open sourced?
A: We’d started planning and design but this also been cancelled, there wasn’t really much of anything useful we could release from this.

So we’re very pleased to have released today the first community accessible version of Nimble. We think Nimble is a unique concept for the Groovy and Grails space and one which we hope will help folks be even more productive. To be clear while most things are locked down there is still a lot of optimization to be done in many areas and documentation for the general public is currently.. well.. lacking. We do plan to correct this in the near future but for now this blog post will give you everything you need to get started.

We call Nimble an “Application Base for Grails” because that is exactly what it is, a base set of components that all web applications require to function. Of course we’ve sprinkled in some sugar here and there to sweeten the deal even further.

So what does Nimble provide?

• Flexible authentication sources including locally hosted accounts, Facebook and OpenID. In the near future we plan to have support for LDAP, SAML 2.x and more
• Fine grained access control from the web tier through to backend service logic. Permissions can be applied to users, roles and groups. Users can be members of an unlimited number of groups. Both users and groups are able to be assigned roles. Enabling permissions to cascade through this structure is where Nimble gains its real access control flexibility. All of this is dynamic and modifiable at run time.
• User profiles and social features such as status updates. We’ve only scratched the surface of what is possible here and hope to really expand this in the future.
• A gorgeous set of interactive UI’s to manage all of the above.

How much does it cost?

Free. Like Grails, Shiro and Spring on which Nimble derives a lot of power from. Apache 2.0 licensed from day 1. Of course we’d appreciate it if you’d like to donate some gold beans to the project, or get involved or even hire us to do some professional work tying in the Nimble codebase.

How do I get started?

Getting started is easy. Nimble is packaged as a grails plugin, you can download a version from Github where the project is hosted or the more advanced folks can fork the project and build their own release binary.

Before getting started ensure you have Grails 1.1.1 available on your path.

Create a new grails application
grails create-app myapp

Install the Nimble plugin
cd myapp
grails install-plugin <download path>/grails-nimble-0.1.zip

Normal grails plugin install will then take over with the final few lines reading:

Plugin nimble-0.1 installed
Plug-in provides the following new scripts:
------------------------------------------
grails jack-be-nimble

Now all we need to do is execute the Nimble install routine
grails jack-be-nimble

This is a very noninvasive procedure. It copies 4 files to your grails conf directory, creates a Nimble directory in your templates directory and adds some SaSS files to your src directory. One of our main goals for this project was to make Nimble as invisible as possible when installed to a host application.

You’re application is now integrated with Nimble, but before we continue we should add some configuration to make sure things run well for you. Open the file NimbleConfig.groovy in grails-app/conf in your text editor of choice. Before continuing to much further we recommend you obtain API keys for recaptcha from http://recaptcha.net/ you might also like to obtain Facebook Connect API keys though these aren’t necessary to get started.

Fill in the config file, each value is fairly self explanatory, we’ve provided a full sample below.

nimble {
  organization {
    name = "Test Organization"
    displayname = "Test Orgization"
    description = "This is a test organization"
    logo = "http://noserver.test.com/logo.png"
    logosmall = "http://noserver.test.com/logosmall.png"
    url = "http://noserver.test.com"
  }

  internal {
    authentication {
      enabled = true
    }
  }

  facebook {
    federationprovider {
      enabled = true
      autoprovision = true
    }

    apikey = "xyz"
    secretkey = "xyz"
  }

  openid {
    federationprovider {
      enabled = true
      autoprovision = true
    }
  }

  recaptcha {
    // These keys are generated by the ReCaptcha service
    publickey = "xyz-xyz"
    privatekey = "xyz"

    // Include the noscript tags in the generated captcha
    noscript = true
  }

  messaging {
    registration {
      subject = "Your new account is ready!"
    }
    passwordreset {
      subject = "Your password has been reset"
      external.subject = "Your password reset request"
    }

    mail {
      from = "Nimble "
      host = "smtp.gmail.com"
      port = 465
      username = ""
      password = ""
      props = ["mail.smtp.auth": "true",
              "mail.smtp.socketFactory.port": "465",
              "mail.smtp.socketFactory.class": "javax.net.ssl.SSLSocketFactory",
              "mail.smtp.socketFactory.fallback": "false"]
    }
  }
}

environments {
  development {
    nimble {
      recaptcha {
        enabled = false
        secureapi = true
      }
    }
  }
  production {
    nimble {
      recaptcha {
        enabled = true
        secureapi = true
      }
    }
  }
}

Save the file and exit your editor.

Launch your application by executing
grails run-app

Open a browser and navigate to http://localhost:8080/myapp or the appropriate URL as indicated by grails. You’ll be welcomed with the basic grails layout. Click on ‘MainController’ to initiate a secure area. You can login as:

• admin / admiN123!
• user / useR123!
• Any openID account
• Any Facebook account if you enabled Facebook Connect API’s

The admin user will be able to access the full UI suite while other users will have access to their profile information.

At this point you’re ready to start exploring Nimble further, there is a lot more on offer but we’ll leave that for a different blog post. We hope you enjoy exploring the software, please do come and chat with us at the Nimble mailing list and we look forward to seeing what the community brings to the table.