DomainClass Dynamic Methods

def b = new Book(title:"The Shining")
if(!b.validate()) {
    b.errors.each {
          println it
    }
}

if (params.password != params.confirm_password) {

    user.errors.reject('user.password.doesnotmatch',                                    // Error code, see grails-app/i18n/message.properties
                       ['password', 'class User'].toArray(),                            // Groovy ListArray cast to Object[]
                       '[Property [{0}] of class [{1}] does not match confirmation]')   // Default mapping string

    // The following helps with field highlighting in your view
    user.errors.rejectValue('password',                                                 // Field in view to highlight using <g:hasErrors> tag
                            'user.password.doesnotmatch')                               // i18n error code

    render(view:'signup', model:[user:user])
    return;
}

def b = new Book(title:"The Shining")
b.constraints.each {
      println it.name
      println it.maxLength
}

def b = new Book(title:"The Shining")
b.properties = this.params

def a = new Author(name:"Stephen King")
             .add(to:"fiction",
                   new Book(title:"IT"))
             .add(to:"non-fiction",
                   new Book(title:"On Writing: A Memoir of the Craft"))
             .save()

def a = new Author(name:"Stephen King")
             .addBook(new Book(title:"IT"))
             .addBook(new Book(title:"The Stand"))
             .save()

def fictBook = new Book(title:"IT")
def nonFictBook = new Book(title:"On Writing: A Memoir of the Craft")
def a = new Author(name:"Stephen King")
             .addToFiction(fictBook)       // 'fiction' is name of relationship property
             .addToNonFiction(nonFictBook) // 'nonFiction' is name of relationship property
             .save()

def b = Book.get(1)
b.delete()

def b = Book.get(1)
b.title = "Blah"
b.discard() // changes won't be applied now

def b = new Book(title:"The Shining")
b.validate()
if(b.hasErrors()) {
    b.errors.each {
          println it
    }
}

def b = new Book(title:"The Shining")
b.save()

println b.ident()

def b = Book.get(1)
b.refresh()

def b = new Book(title:"The Shining")
if( !b.save() ) {
   b.errors.each {
        println it
   }
}

def b = new Book(title:"The Shining")
if( !b.validate() ) {
   b.errors.each {
        println it
   }
}

def noOfBooks = Book.count()

class Book {
   Long id
   Long version
   String title
   Date releaseDate
   String author
}

def c = Book.countByTitle("The Shining")
c = Book.countByTitleAndAuthor("The Sum of All Fears", "Tom Clancy")
c = Book.countByReleaseDateBetween(firstDate, new Date())
c = Book.countByReleaseDateGreaterThanEquals(firstDate)
c = Book.countByTitleLike("%Hobbit%")
c = Book.countByTitleNotEqual("Harry Potter")
c = Book.countByReleaseDateIsNull()
c = Book.countByReleaseDateIsNotNull()

def c = Account.createCriteria()
def results = c {
	like("holderFirstName", "Fred%")
	and {
              between("balance", 500, 1000)
              eq("branch", "London")
	}
	maxResults(10)
	order("holderLastName", "desc")
}

if(Account.exists(1)) {
     // do something
}

Book.executeQuery( String query )
Book.executeQuery( String query, Collection positionalParams )
Book.executeQuery( String query, Collection positionalParams, Map paginateParams )
Book.executeQuery( String query, Map namedParams )
Book.executeQuery( String query, Map namedParams, Map paginateParams )

// simple query
Account.executeQuery( "select distinct a.number from Account a" );
// using with list of parameters
Account.executeQuery( "select distinct a.number from Account a where a.branch = ? and a.created > ?", ['London',lastMonth] );
// using with a single parameter and pagination params (since 0.5)
Account.executeQuery( "select distinct a.number from Account a where a.branch = ?", ['London'], [max:10,offset:5] );
// using with Map of named parameters (since 0.5)
Account.executeQuery( "select distinct a.number from Account a where a.branch = :branch", [branch:'London'] );
// using with Map of named parameters and pagination params (since 0.5)
Account.executeQuery( "select distinct a.number from Account a where a.branch = :branch", [branch:'London', max:10, offset:5] );
// same as previous
Account.executeQuery( "select distinct a.number from Account a where a.branch = :branch", [branch:'London'], [max:10, offset:5] );

Book.executeUpdate( String query )
Book.executeUpdate( String query, Collection positionalParams )

Account.executeUpdate("delete Book b where b.pages > 100")
Account.executeUpdate("delete Book b where b.title like ?", ['Groovy In Action'])
Account.executeUpdate("delete Book b where b.author=?", [Author.get(1)])
Account.executeUpdate("update Book b set b.title='Groovy In Action' where b.title='GINA'")

Book.find( String query )
Book.find( String query, Collection positionalParams )
Book.find( String query, Map namedParams )
Book.find( Book example )

// Dan brown's first book
Book.find("from Book as b where b.author='Dan Brown'")
// with a positional parameter
Book.find("from Book as b where b.author=?",['Dan Brown'])
// with a named parameter (since 0.5)
Book.find("from Book as b where b.author=:author",[author:'Dan Brown'])

def b = new Book(author:"Dan Brown")
Book.find(b) // query by example

Book.findAll()
Book.findAll( String query )
Book.findAll( String query, Collection positionalParams )
Book.findAll( String query, Collection positionalParams, Map paginateParams )
Book.findAll( String query, Map namedParams )
Book.findAll( String query, Map namedParams, Map paginateParams )
Book.findAll( Book example )

// everything
Book.findAll()
// with a positional parameter
Book.findAll("from Book as b where b.author=?",['Dan Brown'])
// 10 books from Dan Brown staring from 5th book ordered by release date
Book.findAll("from Book as b where b.author=? order by b.releaseDate",['Dan Brown'],[max:10,offset:5])

// examples with max/offset usage
def query = "from Book as b where b.author='Dan Brown' order by b.releaseDate"
// first 10 books
Book.findAll(query,[max:10])
// 10 books starting from 5th
Book.findAll(query,[max:10,offset:5])

// examples with named parameters (since 0.5)
Book.findAll("from Book as b where b.author=:author", [author:'Dan Brown'])
Book.findAll("from Book as b where b.author=:author", [author:'Dan Brown'], [max:10, offset:5])
Book.findAll("from Book as b where b.author in (:authors)", [authors:['Dan Brown','Jack London']])

// examples with tables join
Book.findAll("from Book as b where not exists (from Borrow as br where br.book = b)")

// query by example
def b = new Book(author:"Dan Brown")
Book.findAll(b)

class Book {
   Long id
   Long version
   String title
   Date releaseDate
   String author
}

def b = Book.findByTitle("The Shining")
b = Book.findByTitleAndAuthor("The Sum of All Fears", "Tom Clancy")
b = Book.findByReleaseDateBetween(firstDate, new Date())
b = Book.findByReleaseDateGreaterThanEquals(firstDate)
b = Book.findByReleaseDateLessThanEquals(firstDate)
b = Book.findByTitleLike("%Hobbit%")
b = Book.findByTitleIlike("%Hobbit%") // (since 0.5) - ignorecase
b = Book.findByTitleNotEqual("Harry Potter")
b = Book.findByReleaseDateIsNull()
b = Book.findByReleaseDateIsNotNull()

class Book {
   Long id
   Long version
   String title
   Date releaseDate
   String author
}

def results = Book.findAllByTitle("The Shining", [max:10, sort:"title", order:"desc", offset:100] )
results = Book.findAllByTitleAndAuthor("The Sum of All Fears", "Tom Clancy")
results = Book.findAllByReleaseDateBetween(firstDate, new Date())
results = Book.findAllByReleaseDateGreaterThanEquals(firstDate)
results = Book.findAllByTitleLike("%Hobbit%")
results = Book.findAllByTitleIlike("%Hobbit%") // (since 0.5) - ignorecase
results = Book.findAllByTitleNotEqual("Harry Potter")
results = Book.findAllByReleaseDateIsNull()
results = Book.findAllByReleaseDateIsNotNull()

class Book {
   Long id
   Long version
   String title
   Date releaseDate
   String author
}

def b = Book.findWhere(title:"The Shining", author:"Stephen King")

class Book {
   Long id
   Long version
   String title
   Date releaseDate
   String author
}

def books = Book.findAllWhere(author:"Stephen King")

def b = Book.get(1)

// get a list which contains Book instances with ids 2, 1, 3 respectively
def bookList = Book.getAll(2,1,3)
// can take a list of ids as only argument, extremely useful when ids list calculated in code
def bookList = Book.getAll([1,2,3])
// when called without arguments returns list of all objects
def bookList = Book.getAll()

// list everything
def results = Book.list()
// list 10 results
def results = Book.list(max:10)
// list 10 results, offset by 100
def results = Book.list(max:10, offset:100)
// list 10 results, offset by 100, orderd by title in descending order
def results = Book.list(max:10, offset:100, sort:"title", order:"desc")

def results = Book.listOrderByAuthor() // everything
def results = Book.listOrderByTitle(max:10) // 10 results
def results = Book.listOrderByTitle(max:10, offset:100, order:"desc") // 10 results, offset from 100

def results = Book.withCriteria {
    def now = new Date()
    between('releaseDate', now-7, now)
    like('title', '%Groovy%')
}

Book.withTransaction { tx ->
    def b = new Book(title:"Groovy in Action")

    b.save()

    // some logic that goes wrong
    tx.setRollbackOnly()

}