Grails basics part2

 Groovy server pages
 Taglibs
 Validators in grails

 View pages with the extension gsp, gsp
stands for groovy server page
 All default groovy tags along with custom
tags defined in the tag lib can be accessed in
these pages.

 Tags can be created inside taglib folder in grails:
classWidgetsTagLib {
static namespace = “appTags"
ApplicationContext applicationContext
/**
* Extends the regular grails pagination
*/
def paginate = { attrs ->
// DO some operation
}
Tags inside taglib can be accessed on the GSP pages through the name space:
<appsTags:paginate/>
appsTags: Name space defined in the tag lib
Paginate: Method in the file

 Declaring Constraints:
 Within a domain class constraints are defined with the
constraints property that is assigned a code block:
class User {
String login
String password
String email
Integer age
static constraints = {
…
}
}

 You then use method calls that match the property
name for which the constraint applies in combination
with named parameters to specify constraints:
class User {
...
login size: 5..15, blank: false, unique: true
password size: 5..15, blank: false
email email: true, blank: false
age min: 18
}
}

 In that example we've declared that the login
property must be between 5 and 15 characters long,
it cannot be blank and must be unique.We've also
applied other constraints to the password, email
and age properties.
 By default, all domain class properties are not
nullable (i.e. they have an implicit nullable:false
constraint).

 A complete reference for the available constraints
can be found in the Quick Reference section under
the Constraints heading.
class User {
...
// this Date object is created when the constraints are evaluated, not
// each time an instance of the User class is validated.
birthDate max: new Date()
}
}
Custom validator:
class Response {
…
survey blank: false
answer blank: false, validator: { val, obj -> val in
obj.survey.answers }
}
}

 Validating Constraints:
 Call the validate method to validate a domain class
instance:
def user = new User(params)
if (user.validate()) {
// do something with user
}
else {
user.errors.allErrors.each {
println it
}
}
 The errors property on domain classes is an instance of the
Spring Errors interface.The Errors interface provides methods
to navigate the validation errors and also retrieve the original
values.

 Validation Phases:
 Within Grails there are two phases of validation,
the first one being data binding which occurs
when you bind request parameters onto an
instance such as:
def user = new User(params)

 At this point you may already have errors in the
errors property due to type conversion (such as
converting Strings to Dates).You can check these
and obtain the original input value using the Errors
API:
if (user.hasErrors()) {
if (user.errors.hasFieldErrors("login")) {
println user.errors.getFieldError("login").rejectedValue
}
}

 The second phase of validation happens when you call
validate or save.This is when Grails will validate the
bound values againts the constraints you defined.
 For example, by default the save method calls validate
before executing, allowing you to write code like:
if (user.save()) {
return user
}
else {
user.errors.allErrors.each {
println it
}
}

 Importing Constraints:
 Grails 2 introduced an alternative approach to sharing
constraints that allows you to import a set of constraints from
one class into another.
 Let's say you have a domain class like so:
class User {
String firstName
String lastName
String passwordHash
firstName blank: false, nullable: false
lastName blank: false, nullable: false
passwordHash blank: false, nullable: false
}
}

 You then want to create a command object,
UserCommand, that shares some of the properties of
the domain class and the corresponding constraints.You
do this with the importFrom() method:
class UserCommand {
String firstName
String lastName
String password
String confirmPassword
importFrom User
password blank: false, nullable: false
confirmPassword blank: false, nullable: false
}
}

 If you want more control over which constraints are
imported, use the include and exclude arguments.
 Both of these accept a list of simple or regular
expression strings that are matched against the
property names in the source constraints.

 So for example, if you only wanted to import the
'lastName' constraint you would use:
…
importFrom User, include: ["lastName"]
…
}
 or if you wanted all constraints that ended with
'Name':
…
importFrom User, include: [/.*Name/]
…
}

 Validation on the Client:
 Displaying Errors:
▪ Typically if you get a validation error you redirect back to
the view for rendering. Once there you need some way
of displaying errors.
▪ Grails supports a rich set of tags for dealing with errors.
▪ To render the errors as a list you can use renderErrors:
<g:renderErrors bean="${user}" />

 If you need more control you can use hasErrors
and eachError:
<g:hasErrors bean="${user}">
<ul>
<g:eachError var="err" bean="${user}">
<li>${err}</li>
</g:eachError>
</ul>
</g:hasErrors>

 ApplyingValidation to Other Classes:
 Domain classes and command objects support
validation by default.
 Other classes may be made validateable by
defining the static constraints property in the
class (as described above) and then telling the
framework about them.
 It is important that the application register the
validateable classes with the framework. Simply
defining the constraints property is not sufficient.

 TheValidateable Annotation:
 Classes which define the static constraints property and
are annotated with @Validateable can be made
validateable by the framework.
 Consider this example:
// src/groovy/com/mycompany/myapp/User.groovy
package com.mycompany.myapp
import grails.validation.Validateable
@Validateable
class User {
...
login size: 5..15, blank: false, unique: true
password size: 5..15, blank: false
email email: true, blank: false
age min: 18
}
}

Grails basics part2

More Related Content

What's hot (20)

Similar to Grails basics part2 (20)

Recently uploaded (20)

Grails basics part2