The first part of a Grails tutorial (mainly about Domain Classes and Gorm) presented to the Milano JUG.

7. Datasource dataSource { pooled = true driverClassName = "org.hsqldb.jdbcDriver" username = "sa" password = "" } hibernate { cache.use_second_level_cache=true cache.use_query_cache=true cache.provider_class='com.opensymphony.oscache.hibernate.OSCacheProvider' }

8. Datasource environments { development { dataSource { dbCreate = "create-drop" // one of 'create', 'create-drop','update' url = "jdbc:hsqldb:mem:devDB" } } test { dataSource { dbCreate = "update" url = "jdbc:hsqldb:mem:testDb" } } production { dataSource { dbCreate = "update" url = "jdbc:hsqldb:file:prodDb;shutdown=true" } } }

10. Team domain class > grails create-domain-class team class Team { String name String championship String city Long supporters Integer foundationYear static hasMany = [players: Player] static constraints = { name (unique: true, blank: false, size: 2..30) championship (blank: false, inList: ['Serie A', 'Serie B', 'Serie C1', 'Serie C2']) city (blank: true, size: 2..25) supporters (nullable: true) foundationYear (nullable: true) } }

11. Player domain class > grails create-domain-class player class Player { String name String lastName String city Date birth String email static belongsTo = [team: Team] static constraints = { name (blank: false, size: 2..30) lastName (blank: false, size: 2..30) city (blank: true, size: 2..25) birth (nullable:true) email (blank: true, email: true) } }

12. GORM Associations – One to one Unidirectional - class Person { BillingAddress address } class BillingAddress { ... } Bidirectional (no update / delete cascading) - class Person { BillingAddress address } class BillingAddress { Person person }

13. GORM Associations – One to one Bidirectional (update / delete cascading) - class Person { BillingAddress address } class BillingAddress { static belongsTo = [person: Person] }

14. GORM Associations – One to many Update cascading, no delete - class Team { static hasMany = [players: Player] } class Player { ... } Update / delete cascading - class Team { static hasMany = [players: Player] } class Player { static belongsTo = [team: Team] }

17. Team controller > grails generate-controller team Every action is implemented as a closure

18. Team controller - List def list = { if (!params.max) params.max = 10 [ teamList: Team.list( params ) ] } - params is a map containing the request parameters - list is a GORM method, can take parameters: - max, offset, order, sort, ignoreCase, fetch - No explicit return statement - No explicit view

19. Team controller - Show def show = { def team = Team.get( params.id ) if (!team) { flash.message = "Team not found with id ${params.id}" redirect(action: list) } else { return [ team : team ] } } - get is a GORM method - flash is a new scope introduces by Grails - explicit return statement

20. Team controller - Save def save = { def team = new Team(params) if(!team.hasErrors() && team.save()) { flash.message = "Team ${team.id} created" redirect(action: show, id: team.id) } else { render(view: 'create', model: [team: team]) } } - save performs validation and return null if errors are found - explicit view declarations (render)

21. Generate controllers and view > grails generate-views team > grails generate-all player

22. Running the app > grails run-app

23. Application bootstrap def init = { servletContext -> if (GrailsUtil.environment == "development") { def team1 = new Team(name: 'Varese', championship: 'Serie C2', city: 'Varese', supporters: 1000, foundationYear: 1910).save() def team2 = ... def team3 = ... def team4 = ... new Player(name: 'player1', lastName: 'one', city: 'Varese', birth: new Date(), email: 'player1@team.it', team: team1).save() ... new Player(name: 'player11', lastName: 'eleven', city: 'Palermo', birth: new Date(), email: 'player11@team.it', team: team4).save() } }

25. Adding a search form team/list.gsp: <g:form name=”searchForm” action=”search”> Championship: <g:select name=”championship” from=”${Team.constraints.championship.inList}” /> <input type=”submit” value=”Search” /> </g:form>

26. Dynamic finders teamController: def search = { def teamList = Team.findAllByChampionship(params.championship) render(view:'list', model: [teamList: teamList] ) }

27. Dynamic finders - findBy and findAllBy - def team = Team.findByName(‘Juventus’) - def teamList = Team.findAllByCity(‘Milano’) - Composition of properties, boolean logic and comparators: - and, or - LessThan, LessThanEquals, GreaterThan, GreaterThanEquals, Like, Ilike, NotEqual, Between, IsNotNull, IsNull es: Team.findAllByCityLikeAndSupportersGreaterThan(‘Milano’, 1000, [max: 3, offset: 2, sort: &quot;name&quot;, order: &quot;desc&quot;])

28. Multiaction search form <g:form name=&quot;searchForm&quot;> <input type=&quot;text&quot; name=&quot;searchQuery&quot; /> <g:actionSubmit value=&quot;Search by Team&quot; action=&quot;teamSearch&quot; /> <g:actionSubmit value=&quot;Search by City&quot; action=&quot;citySearch&quot; /> </g:form> - Each button sends the form to a different action

29. Hql queries def teamSearch = { def playerList = Player.findAll(&quot;from Player as p where p.team.name = ?&quot;, [&quot;${params.searchQuery}&quot;]) render(view: 'list', model: [playerList: playerList]) } - You can use HQL queries with named and pagination parameters: es: Player.findAll(&quot;from Player as p where p.team.name = :teamName order by p.lastName asc&quot;, [teamName: &quot;Juventus&quot;], [max:10, offset:20])

30. Hibernate Criteria def citySearch = { def c = Player.createCriteria() def playerList = c.list { ilike(&quot;city&quot;, &quot;%${params.searchQuery}%&quot;) } render(view: 'list', model: [playerList: playerList]) } - Uses a Groovy builder to hide Hibernate's Criteria API complexity

31. Hibernate Criteria A more complex example: def c = Account.createCriteria() def results = c { like(&quot;holderFirstName&quot;, &quot;Fred%&quot;) and { between(&quot;balance&quot;, 500, 1000) eq(&quot;branch&quot;, &quot;London&quot;) } maxResults(10) order(&quot;holderLastName&quot;, &quot;desc&quot;) }

32. Pagination problem After the search we see a pagination error: we must modify the generated action and gsp:

33. Pagination <div class=&quot;paginateButtons&quot;> <g:paginate total=&quot;${playerCount}&quot; /> </div> def list = { if (!params.max) params.max = 10 def playerList = Player.list( params ) [ playerList: playerList, playerCount: Player.count()] }

34. Pagination def teamSearch = { def playerList = Player.findAll(&quot;from Player as p where p.team.name = ?&quot;, [&quot;${params.searchQuery}&quot;]) render(view: 'list', model: [playerList: playerList, playerCount: playerList.size()]) } def citySearch = { def c = Player.createCriteria() def playerList = c.list { ilike(&quot;city&quot;, &quot;%${params.searchQuery}%&quot;) } render(view: 'list', model: [playerList: playerList, playerCount: playerList.size()]) }