learntechnology.net

class Department { 
    String name;
    
    String toString() { 
        return name;
    }
}

class Employee { 
    Department department;
    String firstName;
    String lastName;
    int age;
    
    static constraints = {
        firstName(blank:false, nullable:false, size:1..150) 
        lastName(blank:false, nullable:false, size:1..150)  
        age(min:18,max:120)
    }
   
    String toString() {
        return "$firstName $lastName (id: $id)"
    }
}

class BootStrap {

     def init = { servletContext ->
        
         Department a = new Department( name: "HR").save();
         Department b = new Department( name: "Accounting").save();
         Department c = new Department( name: "Sales").save();
         def departments = [a, b, c]
         def firstNames = ["Greg","Fred","Doug","Craig","Dustin","Steve","Kristy","Rick","Wilma"]
         def lastNames = ["Smith","Flinstone","Abbot","Williams","Adams","Goober","Brady","Jones","Heffernen"]
         Random random = new Random()
         1.upto(50) { i ->  
            def first = firstNames[ random.nextInt(9)]
            def last = lastNames[ random.nextInt(9)] + i
            def dep = departments[ random.nextInt(3)]
            def age = random.nextInt(40)+18
            new Employee( firstName: first, lastName: last, age: age, department: dep).save();
         }
         assert( Employee.list().size() == 50 ) 
     }
     def destroy = {
     }
} 

class EmployeeController {
    def index = { }
}

class EmployeeController {
    def scaffold = Employee
}

In our EmployeeController we have one line: def scaffold = Employee. By convention our views that are created dynmaically will call action methods called "list, show, delete, edit, save, update, create." We can provide our own implementation for any of these we want in the controller we just created, for example:

class EmployeeController {
    def scaffold = Employee
    
    def save = { 
        //handle save how we want
    }
}

Grails comes with another feature which will generate all the default CRUD methods for you in the controller. Surprisingly this grails task is: grails generate-controller. Type grails generate-controller Employee from the terminal. Since we already created an Employee controller, it will ask if you have want to overwrite it - type "y" and enter.

Open up the generated EmployeeController class ( in grails-app/controllers ) and you will now see all the CRUD methods, redirects, flash messages, etc. We can now tweak this class anyway we see fit. Maybe we want to change the message displayed after a successful update. Let's go ahead and modify some of the flash messages.

If you look at our Employe domain object, it contained a toString() method that looked like:

String toString() {
    return "$firstName $lastName (id: $id)"
}

Let's use the toString of this Employee object instead of simply displaying the employee id parameter that the default update and save methods use in the default Employee controller we just created.

You'll see the default update and save methods have the following flash messages:
flash.message = "Employee ${params.id} updated" and
flash.message = "Employee ${employee.id} created"

Let's change them to use the Employee toString in the flash messages. Here is the updated "save" and "update" methods:

def save = {
    def employee = new Employee(params)
    if(!employee.hasErrors() && employee.save()) {
        flash.message = "Employee ${employee} created"
        redirect(action:show,id:employee.id)
    }
    else {
        render(view:'create',model:[employee:employee])
    }
}

def update = {
    def employee = Employee.get( params.id )
    if(employee) {
        employee.properties = params
        if(!employee.hasErrors() && employee.save()) {
            flash.message = "Employee ${employee} updated"     
            redirect(action:show,id:employee.id)
        }
        //...
}

The dynamically generated views that our scaffolding created are ok, but what if you want to modify them? You could of course create your gsp pages from scratch, which is fine, but there is an easier way by having grails generate the crud gsp pages for you.

To create our Employee gsp files, you can simply type: grails generate-views Employee. You'll then see four gsp files (create, edit, list, and show) in your grails-app/views/employee directory.

Looking at the create.gsp and edit.gsp file that were created, you will notice that they files are almost identical. Since we're smart developers we realize we should reuse where we can, so let's extract the employee form section out into a Grails' equivalent of a JSP include file - called a "template."

Templates are created with an underscore in front of their name and they are rendered using the g:render tag. We're going to make an _editor.gsp template and place it in the same directory where our other employee view files are located ( /grails-app/views/employee). (This '_editor' name is the same name Graeme Rocher used in his bookmark application, described in more detail in The Definitive Guide to Grails. It makes sense to call it 'editor' since it contains the form that lets you edit the details of the domain object.) Our _editor.jsp should look like:

<table>
<tbody> 
    <tr class='prop'>
        <td valign='top' class='name'>
            <label for='firstName'>First Name:</label>
        </td>
        <td valign='top' class='value ${hasErrors(bean:employee,field:'firstName','errors')}'>
            <input type="text" id='firstName' name='firstName' value="${fieldValue(bean:employee,field:'firstName')}" />
        </td>
    </tr>  
    <tr class='prop'>
        <td valign='top' class='name'>
            <label for='lastName'>Last Name:</label>
        </td>
        <td valign='top' class='value ${hasErrors(bean:employee,field:'lastName','errors')}'>
            <input type="text" id='lastName' name='lastName' value="${fieldValue(bean:employee,field:'lastName')}"/>
        </td>
    </tr> 
    <tr class='prop'>
        <td valign='top' class='name'>
        <td valign='top' class='value ${hasErrors(bean:employee,field:'age','errors')}'>
            <input type='text' id='age' name='age' value="${fieldValue(bean:employee,field:'age')}" />
        </td>
    </tr>  
    <tr class='prop'>
        <td valign='top' class='name'>
            <label for='department'>Department:</label>
        </td>
        <td valign='top' class='value ${hasErrors(bean:employee,field:'department','errors')}'>
            <g:select optionKey="id" from="${Department.list()}" name='department.id' value="${employee?.department?.id}" ></g:select>
        </td>
    </tr>  
</tbody>
</table>

Now we can simplify the create.gsp and edit.gsp files. In the create.jsp, around line 23, you'll see:

<g:form action="save" method="post" >
    <div class="dialog">
        <table>

Simply remove the whole form section you see there, starting with the "table" after the section div class="dialog" section, and have it use our template:

<g:form action="save" method="post" >
    <div class="dialog">
        <g:render template="editor" model="[employee:employee]" />
    </div>

Do the same thing in the edit.gsp file. Now both the create.gsp and edit.gsp will use the editor template for rendering the form content.

You also might want to make a template for displaying an employee that you can use in other pages besides just the show.gsp page. (You could of course even combine the create.gsp and edit.gsp into one file and use a bit of logic to determine what title to display. You could even share the same controller "save" action for creating and updating with a bit of logic also, such as looking for an empty employee.id to signal an insert.)

Lastly, lets just change the index.gsp file in the grails-employee/web-app directory so that it does a simple redirect to our controller list method:

<% response.sendRedirect("employee/list"); %>

Refresh your browser at http://localhost:8080/grails-employee/ and you should see the changes. (No need to have to re-run 'grails run-app', grails will pick up our changes automatically.)