test page for Grails projects

Key Points

References

Reference_description_with_linked_URLs_________________________	Notes________________________________________________________________
qwt Grails Web Lab 1
https://www.tothenew.com/blog/aws-elastic-beanstalk-grails-application/ aws-deploy-grails-web-app-tothenew-AWS Elastic Beanstalk Grails Application .pdf	Deploy Grails Web app to Elastic Beanstalk
https://guides.grails.org/grails-elasticbeanstalk/guide/index.html aws-guides.grails-Deploy to AWS ElasticBeanstalk.pdf	Grails Guide - Deploy Grails Web app to Elastic Beanstalk


https://grails.org	Grails
https://github.com/grails/grails-core/releases/tag/v4.1.0.M2 http://docs.grails.org/4.1.0.M1/guide/introduction.html#whatsNew	grails experimental downloads for 4.2, Groovy 3
https://grails.org/blog/index.htmlutm_campaign=2GM%20Community% 20Engagement&utm_medium=email&_hsmi=95220434&_hsenc=p2ANqtz--Gie_w6ROGkVF89tuvgvf0TvA5zGNNJOLiSLxRPsYRscSTXn6f_b5b9sjFqnW-HpRXh-Y5pJ7MiE3jgwUVf2JwyXRBrQ&utm_content=95220434&utm_source=hs_email	Grails blog
https://github.com/grails/grails-core/releases	Grails releases repo including Milestones *

http://docs.grails.org/latest/guide/introduction.html	Grails 4.0 online doc
http://docs.grails.org/latest/guide/single.pdf https://drive.google.com/open?id=1mMT9PXJMt1LhKMlNIXYdvK17w9_sfSYk	Grails 4.0 single pdf
https://objectcomputing.com/products/grails/grails-roadmap	Grails roadmap to v4.0

https://grailsthreebook.com/assets/pdf/grails3book-sample-preview.pdf https://drive.google.com/open?id=16CCCp9JIztLSy2dDVJl153aogU9klgDX	Grails 3 book - sample - rest api profile
https://www.slideshare.net/paulbowler/grails-patterns-and-practices https://drive.google.com/open?id=1GluRzUKpndHmqx4C3a87H8o0nOTln50W	Grails Patterns and Practices slide deck
https://www.sapient.com/content/dam/sapient/sapientglobalmarkets/pdf/thought-leadership/MarProg_Grails_WP_Web.pdf https://drive.google.com/open?id=165wtwVmVXBQU2JX5uQ2QyS6NXlceS8BU	Grails Overview and Best Practices Guide - v2.0
https://opensourceconnections.com/blog/uploads/2010/01/ Introduction_to_Groovy_and_Grails.pdf	Grails and Groovy Details - 2011
https://drive.google.com/open?id=0BxqKQGV-b4WQVHptM01wVHZQOE0 https://drive.google.com/open?id=0BxqKQGV-b4WQRE52M2ozU2RTR1k	Jim Mason - 2009 - Books Authors Web App in Grails in 1 hour Lab loading instructions doc
	Grails CRUD Scaffolding apps
https://drive.google.com/open?id=1CcNKF5Mab8po1R9G_BSrYQ-uYjf2qDM5	Vogella - 2010 - Grails Web Blog app - decent example on v2.0
https://drive.google.com/file/d/1fL5Q9LH5WB8XsQw71JP_8GoCgjeQt7us/view	Grails Angular CRUD app example - manage customers - older

	Grails REST api example - see docs
https://github.com/budjb/grails-jaxrs	Grails REST Jax-RS generator plugin
http://budjb.github.io/grails-jaxrs/3.x/latest/	Grails REST Jax-RS generator plugin documentation
https://grails.org/plugins/tag/jax-rs	Grails REST Jax-RS plugin list

https://guides.grails.org/grails-vs-nodejs/guide/index.html	Tutorial Migrate React Node.js app to Grails backend



GORM
https://docs.grails.org/latest/guide/GORM.html	Grails GORM overview
http://gorm.grails.org/6.1.x/hibernate/manual/	GORM documentation

https://github.com/smallnest/gen	Generates Go lang structs from many SQL databases could create converter to generate simple domain classes for GORM

Test References

Find grails scripts, files and apps

from ~/

Groovy, Grails scripts

find ./ -iregex ".*setGr.*" 2>/dev/null -exec ls -l {} \;

Groovy work folders & files

find ./ -iregex ".*groovy" 2>/dev/null -exec ls -l {} \; | more

find ./ -ctime -150d -iregex ".*groovy" 2>/dev/null -exec ls -l {} \; | more

gdrv/_work/

use_case_template1.groovy

find ./ -ctime -120d -iregex ".*groovy" 2>/dev/null -exec ls -l {} \; | more

-rw-r--r--@ 1 jimmason staff 372220 Jul 22 09:09 .//learn/blearn-pc/gtest6.groovy

-rw-r--r-- 1 jimmason staff 1807 Dec 9 19:06 .//sfw/gdsl_base.groovy

-rw-r--r-- 1 jimmason staff 1944 Dec 13 18:52 .//sfw/use_case_template1.groovy

Grails apps list

find ./ -iregex ".*spring\/resources.groovy.*" 2>/dev/null -exec ls -l {} \; > ./temp/_grails_apps_list1.txt

grails app list

-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//.gvm/grails/2.4.4/src/grails/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_dev/_gdev/bookstore/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_dev/_gdev/test2/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_dev/_gdev/gtest1/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_dev/qt1/grails-app/test1/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_dev/qt1/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 May  7  2016 .//.grails/wrapper/2.4.4/grails-2.4.4/src/grails/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_gd/_ptp/work/grails/_gdev/bookstore/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//_gd/_ptp/work/grails/_gdev/gtest1/grails-app/conf/spring/resources.groovy
====================
-rw-r--r--  1 jimmason  staff  84 Feb 21  2020 .//Google Drive/_work/learn/blearn-pc/grails/peblock/grails-app/conf/spring/resources.groovy.gz
-rw-r--r--  1 jimmason  staff  84 Feb 21  2020 .//Google Drive/_work/learn/blearn-pc/grails/peblock/build/resources/main/spring/resources.groovy.gz
====================
-rw-r--r--  1 jimmason  staff  84 Sep  3  2018 .//Google Drive/_work/learn/blearn-pc/gtwf1/grails-app/conf/spring/resources.groovy.gz
-rw-r--r--  1 jimmason  staff  84 Sep  3  2018 .//Google Drive/_work/learn/blearn-pc/gtwf1/build/resources/main/spring/resources.groovy.gz
====================
-rw-rw-r--  1 jimmason  staff  47 Feb 21  2020 .//Google Drive/_work/jim-acer/blearn/grails/peblock/grails-app/conf/spring/resources.groovy
-rw-rw-r--  1 jimmason  staff  47 Feb 21  2020 .//Google Drive/_work/jim-acer/blearn/grails/peblock/build/resources/main/spring/resources.groovy
-rw-rw-r--  1 jimmason  staff  47 Sep  3  2018 .//Google Drive/_work/jim-acer/blearn/gtwf1/grails-app/conf/spring/resources.groovy
-rw-rw-r--  1 jimmason  staff  47 Sep  3  2018 .//Google Drive/_work/jim-acer/blearn/gtwf1/build/resources/main/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Google Drive/_ptp/work/grails/_gdev/bookstore/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Google Drive/_ptp/work/grails/_gdev/gtest1/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Feb 21  2015 .//Documents/_ptpdev/eclw2/qwpm/target/test-classes/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Documents/_ptpdev/eclw2/qwpm/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Documents/_ptpdev/eclw2/zdbmgt/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Documents/_ptpdev/eclw1/gttask1/grails-app/conf/spring/resources.groovy
-rw-r--r--  1 jimmason  staff  47 Jul 30  2014 .//Documents/_ptpdev/eclw1/issdmg1/grails-app/conf/spring/resources.groovy

gdrv files

gtwf1

gdrv//_work/learn/blearn-pc/gtwf1/grails-app/views/layouts/main.gsp.gz

gdrv//_work/jim-acer/blearn/gtwf1/grails-app/init/gtwf1/BootStrap.groovy

MAC files

grails4

jim-macbook:_dev jimmason$ ls -l ~/_dev/grails4

total 32

ptp test scripts

jim-macbook:~ jimmason$ ls -l _dev/_gdev

total 576

-rw-r--r-- 1 jimmason staff 2295 Aug 24 2015 JdbcTester1.groovy

-rw-r--r-- 1 jimmason staff 3727 Aug 31 2015 RunJdbcTester1.groovy

drwxr-xr-x 16 jimmason staff 512 Feb 19 2015 bookstore

drwxr-xr-x 3 jimmason staff 96 Aug 28 2015 com

drwxr-xr-x 15 jimmason staff 480 Feb 19 2015 gtest1

-rw-r--r-- 1 jimmason staff 282970 Jun 30 2016 gtest1a.groovy

drwxr-xr-x 15 jimmason staff 480 May 7 2016 test2

udemy grails course test

gdrv//_work/jim-acer/blearn/grails/peblock/grails-app/controllers/peblock/UrlMappings.groovy

Grails Install

Grails Setup

cat ./setGrails4.sh

#!/bin/bash

#

echo "----------- "

echo " setGrails4.sh - adds Grails4 home to path"

echo " "

#

# $GRAILS_HOME set

export PATH=/opt/local/bin:/opt/local/sbin:/Users/jimmason/:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin:/System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands:/usr/local/mysql:/usr/local/bin:usr/local/sbi:n

export MYSQL_JDBC=/Users/jimmason/_dev/lib/mysql-connector-java-5.1.34.jar

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home

export GRAILS_HOME=/Users/jimmason/_dev/grails4

export PATH=$PATH:$GRAILS_HOME:$GRAILS_HOME/bin

export CLASSPATH=$MYSQL_JDBC:$CLASSPATH

echo $PATH

Grails 3x requires JDK8 not JDK11

verify JDK is JDK8 NOT JDK11 ( the default system JDK I set )

grails --version && groovy --version

Project References

Key Concepts

Grails Training

grails v4x books - authors 4 days
http://docs.grails.org/latest/

https://www.djamware.com/post/5d385e00fd741853d22abf5c/building-crud-web-application-using-grails-4-and-mongodb-easily

grails mvc app using spring services - mode coding
https://www.baeldung.com/grails-mvc-application

https://www.google.com/search?client=firefox-b-1-d&q=grails+version+4+tutorials

Grails download & install

http://grails.org/download.html

Grails Application Forge

https://start.grails.org/

Manual Grails install

http://docs.grails.org/latest/guide/gettingStarted.html#downloadingAndInstalling

Set the GRAILS_HOME environment variable to the location where you extracted the zip

On Unix/Linux based systems this is typically a matter of adding something like the following export GRAILS_HOME=/path/to/grails to your profile

Then add the bin directory to your PATH variable:

On Unix/Linux based systems this can be done by adding export PATH="$PATH:$GRAILS_HOME/bin"to your profile

Run version check

grails version

Create shell script to set Grails version

setGrails41.sh

export GRAILS_HOME=`/Library/Grails/grails-4.1.0.M1`
export PATH=$GRAILS_HOME/bin:$PATH

groovy -version

Grails beta versions

Check for Grails versions released in Github here ( including milestones ) - https://github.com/grails/grails-core/releases

For a given release / milestone - check the Github issues to see what's important that's still open - https://github.com/grails/grails-core/issues

https://github.com/grails/grails-core/releases/tag/v4.1.0.M1

http://docs.grails.org/4.1.0.M1/guide/introduction.html#whatsNew

install from Zip file

ensure GRAILS_HOME, GROOVY_HOME, JAVA_HOME are set

ensure any CLASSPATH and path updates are correct

to validate, run:

grails -version

Grails docs on skwebteam

grails4-update-Slide_Deck_Introducing_Grails_4_Webinar.pdf

grails-181115-tutorial-guestbook-java-web-app-vogella.com-.pdf

gorm-basics-tutorial-relations-maps.pptx

grails-best-practices-web-profile-2016-MarProg_Grails_WP_Web.pdf

grails-web-mvc-tutorial-v4-mongodb-2019-vgood.pdf

grails-plugins.github.io-DB Reverse Engineering Plugin - Reference Documentation.pdf

Grails v4.0 Features

https://objectcomputing.com/products/grails/grails-roadmap

Groovy 2.5
GORM 7.0 (Hibernate 5.2 minimum, Java 8 baseline)
Java 8 Baseline
Java 11 Support
Spring 5.1
Spring Boot 2.1
Micronaut Integration

Grails JAX-RS plugin documentation ( for Grails v3x )

http://budjb.github.io/grails-jaxrs/3.x/latest/guide/introduction.html

The jaxrs project is a set of Grails plugins that supports the development of RESTful web services based on the Java API for RESTful Web Services (JSR 311: JAX-RS).

It is targeted at developers who want to structure the web service layer of an application in a JSR 311 compatible way but still want to continue to use Grails' powerful features such as GORM, automated XML and JSON marshalling, Grails services, Grails filters and so on. This plugin is an alternative to Grails' built-in mechanism for implementing RESTful web services.

Features

Makes the JSR 311 (JAX-RS) available to Grails applications for developing RESTful web services.
New Grails artefact types, Resource and Provider, for JAX-RS classes.

JAX-RS Resource classes under grails-app/resources are auto-detected and can be modified at runtime.
JAX-RS Provider classes under grails-app/providers are auto-detected and can be modified at runtime.

Extended Grails command line interface

Create new resources and unit test templates via grails create-resource <resource name>.
Generate ready-to-use resources from domain objects via grails generate-resources <domain class name>.

Scaffolding

Generate RESTful service interfaces for Grails domain objects.
Content negotiation support for XML and JSON representations.

Ability to use any Grails feature within JAX-RS resources and providers such as:

GORM can be used for interacting with persistent domain objects.
Grails filters for intercepting requests to JAX-RS resources. ( Deprecated )
Grails services which can be auto-injected by name.

Entity providers

Domain object providers that convert between Grails domain objects and XML or JSON representations.
Support classes for developing custom entity providers.
Support for content negotiation based on the Accept request header.

Easy integration testing of JAX-RS resources and providers.
Plugin users may choose between Jersey and Restlet as JAX-RS implementations by means of configuration.
jaxrs applications can be deployed to Google App Engine (GAE).

Tutorial Migrate React Node.js app to Grails backend

https://guides.grails.org/grails-vs-nodejs/guide/index.html

To complete this guide, you will need the following:

Some time on your hands
A decent text editor or IDE
JDK 1.7 or greater installed with JAVA_HOME configured appropriately

To get started do the following:

Download and unzip the source

or

Clone the Git repository:
git clone https://github.com/grails-guides/grails-vs-nodejs.git

The Grails guides repositories contain two folders:

initial Initial project. Often a simple Grails app with some additional code to give you a head-start.
complete A completed example. It is the result of working through the steps presented by the guide and applying those changes to the initial folder.

To complete the guide, go to the initial folder

cd into grails-guides/grails-vs-nodejs/initial

and follow the instructions in the next sections.

You can go right to the completed example if you cd into grails-guides/grails-vs-nodejs/complete

The completed sample project for this article can be found at:

https://github.com/grails-guides/grails-vs-nodejs/tree/master/complete

create react profile app

Every Grails project begins with a single create-app command. For the purposes of following along with this guide, you may choose to install Grails via the official website, or using sdkman (recommended). However, there is no need to install the framework on your machine to create your Grails app - instead, let’s browse to http://start.grails.org and create our application using the Grails Application Forge.

Choose the latest version of Grails (3.3.0 as of the time of writing) and select the react profile.

With the use of application profiles, Grails allows you to build modern web applications. There are profiles to facilitate the construction of REST APIs or Web applications with a Javascript front-end

start client and server apps

Once you’ve downloaded your application, expand it into a directory of your choice, cd into the project, and run the following two commands (in two separate terminal sessions):

~ ./gradlew server:bootRun   //Windows users use "gradlew.bat"

//in a second terminal session
~ ./gradlew client:bootRun

gradle wrapper can eliminate need to install Grails locally

The gradlew command launches the Gradle "wrapper”, which is provided by the Gradle build tool that is used in all Grails projects since Grails 3.0. The wrapper is a special script that actually download and install the Gradle build tool (if necessary) before running your commands. Gradle will then download all needed dependencies (including Grails) and install them in your project (caching them for future use as well). This is why you don’t need to install Grails on your machine: if your project includes the Gradle wrapper, it will handle that for you.

gradle is similar to npm for build management

It doesn’t provide the CLI that npm offers but it fulfills a similar purpose in dependency management and build-processing. When a Gradle command (or "task") is run, Gradle will first download all dependencies listed in the project’s build.gradle file, similar to running npm install.

What about the server and client portion of those two commands? Because we’re using the react profile, Grails has actually created two separate “apps” for us - the backend Grails application, and the React application (which in turn is generated via create-react-app). Gradle treats these two apps as independent subprojects, with the above names. This is called a multi-project build.

When running a Gradle “task” from the project root directory, anything after ./gradlew [project_name]: will match a task specific to that subproject. The bootRun task is configured in both projects to start the respective app.

Where does bootRun come from? This Gradle task is inherited from the Spring Boot framework, upon which Grails is based. Of course create-react-app projects don’t have such a task by default. The React profile provides the client:bootRun task as a wrapper around the npm/yarn start script. This allows you to use advanced Gradle features like running both server and client in parallel mode with one command. For developers, running ../gradlew client:bootRun is the same as running npm start (or yarn start) in a stock create-react-app project, and in fact you can run the client app exactly that way if you have npm/yarn installed on your machine.

Once the gradlew commands have completed downloading dependencies and launching their respective apps, you should be able to browse to http://localhost:8080 to see the Grails backend application, and http://localhost:3000 to view the React app.

Data source setup - postgresql

GORM - Grails Object Relational Management

http://gorm.grails.org/6.1.x/hibernate/manual/#quickStartGuide

A domain class can be created with the create-domain-class command if you are using Grails, or if you are not using Grails you can just create the .groovy file manually:

grails create-domain-class helloworld.Person

This will create a class at the location grails-app/domain/helloworld/Person.groovy such as the one below:

package helloworld

class Person {
}

If you have the configured the dataSource.dbCreate property and set it to "update", "create" or "create-drop", GORM will automatically generate/modify the database tables for you.

You can customize the class by adding properties:

class Person {
    String name
    Integer age
    Date lastVisit
}

Once you have a domain class try and manipulate it with console command in Grails by typing:

grails console

This loads an interactive GUI where you can run Groovy commands with access to the Spring ApplicationContext, GORM, etc.

Or if you are not using Grails here is a unit test template (using Spock) that can be run to test out the examples:

import spock.lang.*
import grails.gorm.annotation.Entity
import grails.transaction.Rollback
import org.grails.orm.hibernate.HibernateDatastore
import org.springframework.transaction.PlatformTransactionManager

class ExampleSpec extends Specification {

    @Shared @AutoCleanup HibernateDatastore hibernateDatastore
    @Shared PlatformTransactionManager transactionManager

    void setupSpec() {
       hibernateDatastore = new HibernateDatastore(Person)
       transactionManager = hibernateDatastore.getTransactionManager()
    }

    @Rollback
    void "test execute GORM standalone in a unit test"() {
       // your logic here
    }
}

@Entity
class Person {
    ...
}

3.1. Basic CRUD

Try performing some basic CRUD (Create/Read/Update/Delete) operations.

3.1.1. Create

To create a domain class use Map constructor to set its properties and call the save() method:

def p = new Person(name: "Fred", age: 40, lastVisit: new Date())
p.save()

The save() method will persist your class to the database using the underlying Hibernate ORM layer.

The save() method is defined by the GormEntity trait.

3.1.2. Read

GORM transparently adds an implicit id property to your domain class which you can use for retrieval:

def p = Person.get(1)
assert 1 == p.id

This uses the static get(id) method that expects a database identifier to read the Person object back from the database.

You can also load an object in a read-only state by using the read(id) method:

def p = Person.read(1)

In this case the underlying Hibernate engine will not do any dirty checking and the object will not be persisted. Note that if you explicitly call the save() method then the object is placed back into a read-write state.

In addition, you can also load a proxy for an instance by using the load(id) method:

def p = Person.load(1)

This incurs no database access until a method other than getId() is called. Hibernate then initializes the proxied instance, or throws an exception if no record is found for the specified id.

3.1.3. Update

To update an instance, change some properties and then call save() again:

def p = Person.get(1)
p.name = "Bob"
p.save()

3.1.4. Delete

To delete an instance use the delete() method:

def p = Person.get(1)
p.delete()

oks and authors tables - SQL

books authors tables

create table author (   id bigint not  auto_increment  null,   version bigint not null,   name varchar(255) not null,  email varchar(255) null,  primary key (id)) ENGINE=InnoDB;

create table book (   id bigint not  auto_increment  null,   version bigint not null,   title varchar(255) not null,  type varchar(255), description varchar(2048),  sold bigint null,  primary key (id)) ENGINE=InnoDB;

create table author_books (   author_id bigint not null,   book_id bigint not null,   primary key (author_id, book_id)) ENGINE=InnoDB;

alter table author_books add index FKauthor_books_2_books (book_id), add constraint FKauthor_books_2_books foreign key (book_id) references book (id);

alter table author_books add index FKauthor_books_2_authors (author_id), add constraint FKauthor_books_2_authors foreign key (author_id) references author(id);

Books and authors output classes from DB plugin

books and authors classes

class Author { 
String name
String email
String phone
static hasMany = [books: Book]
};


class Book { 
String title
String publisher
BigDecimal price
String description 
Integer quantitySold
static hasMany = [authors: Author]
static belongsTo = Author
};


class Author_Books { 
String name
String email
static hasMany = [books: Book]
};

Final version of Books and authors output classes

Example of DB Reverse Engineering Output

Yes GORM. The reverse engineering for Grails is a little simpler because all that is needed are Domain classes and the framework handles all the hibernate mappings. So for example a DB table called Application would only need a single Domain class instead of a Domain, DAO and XML Mapping file. Here is an example with one-to-many and many-to-one relationships

DB Reverse Engineering Example

class Application {
BigDecimal gpa
Date submitDate
String appliedFlag
String acceptedFlag
String deniedFlag
String managerNetid
Date timeStamp
AcademicYear academicYear
Quarter quarter
Student student
Set<ApplicationFile> applicationFiles = []
Set<ApplicationQa> applicationQas = []
Set<ApplicationAccepted> applicationAccepteds = []
Set<ApplicationDenied> applicationDenieds = []
 
static hasMany = [applicationAccepteds: ApplicationAccepted,
                  applicationDenieds: ApplicationDenied,
                  applicationFiles: ApplicationFile,
                  applicationQas: ApplicationQa]
 
static belongsTo = [AcademicYear, Quarter, Student]
 
static mapping = {
version false
quarter column: "quarter_code"
student column: "sid"
applicationAccepteds cascade: "save-update, delete-orphan"
applicationDenieds cascade: "save-update, delete-orphan"
applicationQas cascade: "save-update"
}
 
static constraints = {
submitDate nullable: true
appliedFlag maxSize: 1
acceptedFlag maxSize: 1
deniedFlag maxSize: 1
managerNetid nullable: true, maxSize: 36
}
}

There used to be a plugin for Grails that had this functionality and uses the hibernate-tools library but it stopped being maintained a while ago and the newer Grail releases are not compatible. I figured since MyEclipse uses the same hibernate-tools to generate Java code that maybe it would be possible to expand on that to generate Grails domain classes?

http://grails-plugins.github.io/grails-db-reverse-engineer/grails3v4/index.html

Depends on Hibernate Tools, Maven, Eclipse

https://hibernate.org/tools/

Golang GORM

GORM - create tables from GOR

http://jinzhu.me/gorm/

Full-Featured ORM (almost)
Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
Callbacks (Before/After Create/Save/Update/Delete/Find)
Preloading (eager loading)
Transactions
Composite Primary Key
SQL Builder
Auto Migrations
Logger
Extendable, write Plugins based on GORM callbacks
Every feature comes with tests

install

go get -u github.com/jinzhu/gorm

simple crud example

package main

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
  gorm.Model
  Code string
  Price uint
}

func main() {
  db, err := gorm.Open("sqlite3", "test.db")
  if err != nil {
    panic("failed to connect database")
  }
  defer db.Close()

  // Migrate the schema
  db.AutoMigrate(&Product{})

  // Create
  db.Create(&Product{Code: "L1212", Price: 1000})

  // Read
  var product Product
  db.First(&product, 1) // find product with id 1
  db.First(&product, "code = ?", "L1212") // find product with code l1212

  // Update - update product's price to 2000
  db.Model(&product).Update("Price", 2000)

  // Delete - delete product
  db.Delete(&product)
}

Generate Golang structs from SQL databases

https://github.com/smallnest/gen

could create a converter to generate GORM domain classes from Golang structs

or

directly create tool to build GORM domain classes from db tables using JDBC metadata and groovy

benefits of direct tool:

no external dependencies
could extend to NoSQL
can pickup reference relations as "has" or "owns"
can pickup primary key

Grails with Groovy 3x

4.1 M builds use Groovy 3

https://github.com/grails/grails-core/releases/tag/v4.1.0.M1

Potential Value Opportunities

Potential Challenges

Grails Java JDK compatibility

At some later point, ( 2020 or ? ), Grails will catch up with supported Java JDKs but not now.

The low-end default that will work is always JDK 8.

Groovy 2x still works with JDK 8 ( used by Grails 4x ) but not JDK 11 without a lot of custom work.

Grails 4 upgrade issues related to Java etc

https://github.com/grails/grails-core/wiki/Grails-4-Upgrade

Bug> Grails console can't open groovy file from menu or cli

bug> can't open a file from grails console using the file menu

workaround> use CTL + O

open groovyconsole normally
use CTL + O to open file selector window
select a groovy file
press Enter
<< file opens normally in groovy console

option 1> specify the file name on the cli cmd to open grails console
specify the file to open on the grails console command using relative url
grails console -f ./zfiles/gtest-2a1.groovy
<< no file shown

option 2> manually copy file contents to console window
open grails console
open the file from the File menu ( nothing shows )
open the same groovy file in another text editor
copy and paste the entire contents to the console window
add a comment line
File > save
check the saved file in the text editor to see the comment line exists

Grails 4.1 M++ – Groovy 3 and JDK11

Candidate Solutions

SWT Grails Books and Authors Lab - 2009 - V2X

<< see the pdf for the images >>

Grails lab concepts

The Grails lab uses the c:\ebtnoweos folder to build and run your Grails Web database application.
You will use both the Explorer browser and a DOS cmd shell to generate and run your Grails Web
application.

Before you begin you'll need to start the WebSphere Community Edition server (WAS) that includes
the Derby database you'll use to store you data. You start WAS by clicking wcestart from Explorer.

At the end of the lab click wcestop to end the WAS server.

grails lab flow

• Understand grails datasource configuration
• Start wasce derby server
• Create-app qwex1
• create-domain-class author
• console edit for author
• generate-all for author
• create-domain-class book
• console edit for book
• generate-all for book
• run-app
• open a browser by clicking: http://localhost:9080/qwex1
• create authors
• create books

grails datasource configuration options

The datasource config file defines how grails uses a target database for a specific environment
( development, test or prod )

Sample datasource.groovy config file for the lab

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'
}
// environment specific settings
environments {
development {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:hsqldb:mem:devDB"
}
}
test {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:derby://localhost:1527/sample"
driverClassName = "org.apache.derby.jdbc.ClientDriver"
username = "APP"
password = "APP"
}
}
testh {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:mem:testDb"
}
}
testm {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost:3306/sample"
driverClassName = "com.mysql.jdbc.Driver"
username = "root"
password = ""
}
}
production {
dataSource {
03/14/09 Jim Mason, copyright 2009 3 of 18
ebt-now Enterprise Open-Source Labs
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}

Edit the grails configuration for your data source

When you create your grails application, it generates a default datasource.groovy

config file that does
not include the references for derby and mysql as shown above.

You'll copy the datasource.groovy file

from the savedata folder ( C:\ebtnoweos\savedata\grails)

overlaying the generated version of this file in the

C:\ebtnoweos\grails\qwex1\grails-app\conf folder of
your application.

dbCreate controls how the database tables are maintained from grails
The dbCreate property of the DataSource definition is important as it dictates what Grails should do at runtime with regards to automatically generating the database tables from GORM classes.

The options are:
 create-drop - Drop and re-create the database when Grails is run
 create - Create the database if it doesn't exist, but don't modify it if it does. Deletes existing data.
 update - Create the database if it doesn't exist, and modify it if it does exist

Both create-drop and create will destroy all existing data hence use with caution!

To prevent ANY database changes, comment out dbCreate in the config

In development mode dbCreate is by default set to "create-drop":

dataSource {
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
}

What this does is automatically drop and re-create the database tables on each restart of the application. Obviously this may not be what you want in production or a test server.

Grails – generate Web database application

Start WASCE Derby database server
In Explorer, browse to the root lab folder ( c:\ebtnoweos )

> click wcestart.bat
< WebSphere application server (WAS) starts running after a few minutes
a Dos command window opens with a server startup message

You can open a Web browser on the WAS server by clicking:

http://localhost:8080

Click on the Administrative console to login as the administrator

When prompted for a user id and password,
user = system
password = manager
< the WAS admin console is shown

At the end of the lab, you can click the Shutdown button to shutdown your WAS server

create a Grails application from the cmd line

Click Start > Run > type cmd > Ok
< a DOS cmd shell window opens
Type 'cd \ebtnoweos' to change to the root lab directory
> Type 'setgrails.bat'
< this sets the grails runtime environment

Type 'cd grails'
< you're in the grails app directory

create a grails application: qwex1

At the prompt, Type
'grails create-app qwex1'

< grails generates a basic Web application
change to the application directory
Type 'cd qwex1'

Note: IF you have a grails compile error on any step, always run 'grails test clean' before doing
anything else!

Replace the datasource.groovy config file

The generated datasource.groovy config file is not configured for the Derby database running in WAS CE.

You will copy another datasource.groovy config file replacing the one generated in your application folder.

In Explorer, browse to the C:\ebtnoweos\savedata\grails folder.
Select the datasource.groovy file > right button menu > copy
Browse to the conf folder in your application: C:\ebtnoweos\grails\qwex1\grails-app\conf
> Click on the folder ( not a file )
> right button menu (RBM) > select paste > when prompted say yes to replace the existing file
You've used a new datasource.groovy file that can now connect to the WAS CE Derby database

create an Author domain entity

In the DOS cmd shell, type 'dir' to ensure you are in the grails application folder ( C:\ebtnoweos\grails\
qwex1).
> Type 'grails test create-domain-class author'
< grails generates a Author entity

Edit the Author to add domain attributes

Using grails console, we'll edit the author to add attributes ( fields and methods )
Type 'grails test console'
Grails opens the console in the test environment
> File > Open > select the author.groovy file > Open
< the author.groovy file is loaded into the console editor

You'll add the code shown below in the editor

class Author {
static constraints = {
}
String lastname
String firstname
String email
String phone
}
Do NOT make punctation mistakes on the “ { ) etc

> Click File > Exit to leave the console
< when prompted to save the file, click Yes
The updated Author entity is saved

Generate the Author controller and Web views

Type 'grails test generate-all author'

< grails generates the Author Web views and controller

create a Book domain entity

In the DOS cmd shell, type 'dir' to ensure you are in the grails application folder ( C:\ebtnoweos\grails\
qwex1).
> Type 'grails test create-domain-class book'
< grails generates a Book entity

Edit the Book to add domain attributes

Using grails console, we'll edit the book to add attributes ( fields and methods )
Type 'grails test console'
Grails opens the console in the test environment
> File > Open > select the book.groovy file > Open
< the book.groovy file is loaded into the console editor

You'll add the code shown below in the editor

class Book {
static constraints = {
}
String title
String publisher
BigDecimal price
String publishDate
Author author
}

Do NOT make punctation mistakes on the “ { ) etc
> Click File > Exit to leave the console
< when prompted to save the file, click Yes

The updated Book entity is saved
If the console reopens empty, just click File > Exit
> when prompted to save, click No
You're back at the cmd shell

Generate the Book controller and Web views

Type 'grails test generate-all book'

< grails generates the Book Web views and controller

run your grails application

At the cmd prompt, type 'grails test run-app'
< the internal Jetty application server starts running
wait until you see the server is running message below

Open a Web browser and go to the application URL

http://localhost:9080/qwex1

< the browser opens to the main page of your application

Edit the Author information as needed

Click the Author list to see the full list of authors
Click Home to return to the main application screen with all the controllers
Edit the Book information as needed
Click the Book Controller
< the Book editor opens
< click New book to create a new book

Notice the first field has a drop down list box to select an author.
In a more advanced lab we'll show you how to display the author's name in the listbox not just the id
The list shows all the books you've entered:

Congratulations – you've built a Web database application in 1 hour!

Simple Grails CRUD app on Grails 2x

User

EBC

Account

Device

Location

Energy

Steps after Grails setup

grails createApp gtcrud1

cd gtcrud1

grails console

add the application folder to the grails path in the console

Step-by-step guide for Example

sample code block

sample code block

Recommended Next Steps

Related articles

Browser not supported