Dueuno Elements

class BootStrap {

    ApplicationService applicationService (1)

    def init = { servletContext ->
        applicationService.init {
            registerFeature( (2)
                    controller: 'movie',
                    icon: 'fa-film',
                    favourite: true,
            )
        }
    }
}

class TMovie implements MultiTenant<TMovie> {
    LocalDateTime dateCreated

    String title
    Integer released

    static hasMany = [actors: TActor]

    static constraints = {
    }
}

class TActor implements MultiTenant<TActor> {
    LocalDateTime dateCreated

    String firstname
    String lastname

    static constraints = {
    }
}

@Secured(['ROLE_CAN_EDIT_MOVIES']) (1)
class MovieController implements ElementsController { (2)

    def index() {
        // will display a list of movies
    }

    def create() { (3)
        // will display a form with the movie title
    }

    def onCreate() { (3)
        // will create the movie record on the database
    }

    def edit() {
        // will display the details of a movie
    }

    def onEdit() {
        // will update the movie record on the database
    }

    def onDelete() {
        // will delete a movie record from the database
    }
}

@Secured(['ROLE_CAN_EDIT_MOVIES'])
class MovieController implements ElementsController {

    MovieService movieService (1)

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            filters.with {
                addField(
                        class: TextField,
                        id: 'find',
                        label: 'default.filters.text',
                        cols: 12,
                )
            }
            sortable = [
                    title: 'asc',
            ]
            columns = [
                    'title',
                    'released',
            ]

            body.eachRow { TableRow row, Map values ->
                // Do not execute slow operations here to avoid slowing down the table rendering
            }
        }

        c.table.body = movieService.list(c.table.filtersParams, c.table.fetchParams)
        c.table.paginate = movieService.count(c.table.filtersParams)

        display content: c
    }

    private buildForm(TMovie obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = TMovie
            addField(
                    class: TextField,
                    id: 'title',
            )
            addField(
                    class: NumberField,
                    id: 'released',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate() {
        def obj = movieService.create(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def edit() {
        def obj = movieService.get(params.id)
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit() {
        def obj = movieService.update(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def onDelete() {
        try {
            movieService.delete(params.id)
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

@CurrentTenant
class MovieService {

    private DetachedCriteria<TMovie> buildQuery(Map filters) {
        def query = TMovie.where {}

        if (filters.containsKey('id')) query = query.where { id == filters.id }

        if (filters.find) {
            String search = filters.find.replaceAll('\\*', '%')
            query = query.where {
                title =~ "%${search}%"
            }
        }

        // Add additional filters here

        return query
    }

    TMovie get(Serializable id) {
        // Add any relationships here (Eg. references to other DomainObjects or hasMany)
        Map fetch = [
                actors: 'join',
        ]

        return buildQuery(id: id).get(fetch: fetch)
    }

    List<TMovie> list(Map filterParams = [:], Map fetchParams = [:]) {
        if (!params.sort) params.sort = [dateCreated: 'asc']

        // Add single-sided relationships here (Eg. references to other Domain Objects)
        // DO NOT add hasMany relationships, you are going to have troubles with pagination
//        params.fetch = [
//                actors: 'join',
//        ]

        def query = buildQuery(filterParams)
        return query.list(fetchParams)
    }

    Integer count(Map filterParams = [:]) {
        def query = buildQuery(filterParams)
        return query.count()
    }

    TMovie create(Map args = [:]) {
        if (args.failOnError == null) args.failOnError = false

        TMovie obj = new TMovie(args)
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    TMovie update(Map args = [:]) {
        Serializable id = ArgsException.requireArgument(args, 'id')
        if (args.failOnError == null) args.failOnError = false

        TMovie obj = get(id)
        obj.properties = args
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    void delete(Serializable id) {
        TMovie obj = get(id)
        obj.delete(flush: true, failOnError: true)
    }
}

...

dependencies {
...

    implementation 'org.dueuno:elements-core:2.4.0'
}

package com.example

import dueuno.elements.core.ApplicationService

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->
        applicationService.init {
            // It's fine to leave this empty at the moment
        }
    }

    def destroy = {
    }
}

$ ./gradlew bootRun

package com.example

import dueuno.elements.core.ApplicationService

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->
        applicationService.init {

            registerFeature(
                    controller: 'person',
                    icon: 'fa-user',
                    favourite: true,
            )

        }
    }

    def destroy = {
    }
}

$ ./gradlew bootRun

package com.example

import dueuno.elements.core.ElementsController
import grails.validation.Validateable

class PersonController implements ElementsController {

    def index() {
        // Displays a list of people
    }

    def create() {
        // Displays a form to input person data
    }

    def onCreate(PersonValidator val) {
        // Creates a new person
    }

    def edit() {
        // Displays a form to edit person data
    }

    def onEdit(PersonValidator val) {
        // Updates a person record
    }

    def onDelete() {
        // Deletes a person
    }
}

class PersonValidator implements Validateable {
    // Will validate user input
}

package com.example

import dueuno.elements.contents.*
import dueuno.elements.controls.*
import dueuno.elements.core.ElementsController
import grails.validation.Validateable

import java.time.LocalDate

class PersonController implements ElementsController {

    static final List personRegistry = [
            [id: 1, firstname: 'Gianluca', lastname: 'Sartori', birthdate: LocalDate.of(1979, 6, 24)],
            [id: 2, firstname: 'John Luke', lastname: 'Taylor', birthdate: LocalDate.of(1921, 6, 24)],
            [id: 3, firstname: 'Juan Lucas', lastname: 'Sastre', birthdate: LocalDate.of(1942, 6, 24)],
    ]

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            columns = [
                    'firstname',
                    'lastname',
                    'birthdate',
            ]
        }

        c.table.body = personRegistry
        c.table.paginate = personRegistry.size()

        display content: c
    }

    private ContentForm buildForm(Map obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = PersonValidator
            addField(
                    class: TextField,
                    id: 'firstname',
            )
            addField(
                    class: TextField,
                    id: 'lastname',
            )
            addField(
                    class: DateField,
                    id: 'birthdate',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate(PersonValidator val) {
        if (val.hasErrors()) {
            display errors: val
            return
        }

        def last = personRegistry.max { it.id }
        personRegistry << [
                id: last ? last.id + 1 : 1,
                firstname: params.firstname,
                lastname: params.lastname,
                birthdate: params.birthdate,
        ]

        display action: 'index'
    }

    def edit() {
        def obj = personRegistry.find { it.id == params.id }
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit(PersonValidator val) {
        if (val.hasErrors()) {
            display errors: val
            return
        }

        def obj = personRegistry.find { it.id == params.id }
        obj.firstname = params.firstname
        obj.lastname = params.lastname
        obj.birthdate = params.birthdate

        display action: 'index'
    }

    def onDelete() {
        try {
            personRegistry.removeIf { it.id == params.id }
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

class PersonValidator implements Validateable {
    String firstname
    String lastname
    LocalDate birthdate
}

$ ./gradlew bootRun

dependencies {
    ...
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
}

spring:
  main:
    banner-mode: 'log'
  devtools:
    restart:
      additional-exclude:
        - '*.gsp'
        - '**/*.gsp'
        - '*.gson'
        - '**/*.gson'
        - 'logback.groovy'
        - '*.properties'

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <conversionRule conversionWord="highlightLogLevel" converterClass="dueuno.commons.logs.HighlightLogLevel" />

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %highlightLogLevel(%-5level) [%thread] %-40.40logger{36} : %highlightLogLevel(%msg%n)</pattern>
        </encoder>
    </appender>

    <property resource="application.yml" />
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${info.app.name}/logs/${info.app.name}.log</file>

        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${info.app.name}/logs/archive/${info.app.name}.%d{yyyy-MM-dd}.%i.log.zip</fileNamePattern>
            <cleanHistoryOnStart>true</cleanHistoryOnStart>
            <maxHistory>10</maxHistory>
            <maxFileSize>10MB</maxFileSize>
            <totalSizeCap>100GB</totalSizeCap>
        </rollingPolicy>

        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %-40.40logger{36} : %msg%n</pattern>
        </encoder>
    </appender>

    <root level="ERROR">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>

    <logger name="org.springframework.boot.SpringApplication" level="INFO" />
    <logger name="dueuno" level="INFO" />
    <logger name="demo" level="DEBUG" />

</configuration>

10:53:29.113 INFO  [restartedMain] o.s.boot.SpringApplication               :
>                                                                            <
>                         _                                                  <
>                        | |  ELEMENTS                                       <
>                      __| |_   _  ___ _   _ _ __   ___                      <
>                     / _` | | | |/ _ \ | | | '_ \ / _ \                     <
>                    | (_| | |_| |  __/ |_| | | | | (_) |                    <
>                     \__,_|\__,_|\___|\__,_|_| |_|\___/                     <
>                         2024 (c) https://dueuno.com                        <
>                                                                            <
>                                                                            <


Configuring Spring Security Core ...
... finished configuring Spring Security Core

10:53:31.227 INFO  [restartedMain] d.e.core.ConnectionSourceService         : Installed datasource connection 'DEFAULT: jdbc:h2:mem:devDb;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE'
10:53:31.265 INFO  [restartedMain] d.elements.tenants.TenantService         : Creating new tenant 'DEFAULT'...
10:53:31.300 INFO  [restartedMain] d.elements.security.SecurityService      : Created authority 'ROLE_SECURITY'
10:53:31.306 INFO  [restartedMain] d.elements.security.SecurityService      : Created authority 'ROLE_USER'
10:53:31.308 INFO  [restartedMain] d.elements.security.SecurityService      : DEFAULT: Created group 'USERS' with authorities: [ROLE_USER]
10:53:31.313 INFO  [restartedMain] d.elements.security.SecurityService      : Created authority 'ROLE_ADMIN'
10:53:31.314 INFO  [restartedMain] d.elements.security.SecurityService      : DEFAULT: Created group 'ADMINS' with authorities: [ROLE_ADMIN]
10:53:31.318 INFO  [restartedMain] d.elements.security.SecurityService      : Created authority 'ROLE_SUPERADMIN'
10:53:31.319 INFO  [restartedMain] d.elements.security.SecurityService      : DEFAULT: Created group 'SUPERADMINS' with authorities: [ROLE_SUPERADMIN]
10:53:31.417 INFO  [restartedMain] d.elements.security.SecurityService      : DEFAULT: Created user 'super' in groups: [SUPERADMINS, USERS]
10:53:31.511 INFO  [restartedMain] d.elements.security.SecurityService      : DEFAULT: Created user 'admin' in groups: [USERS, ADMINS]
10:53:31.528 INFO  [restartedMain] d.elements.tenants.TenantService         : --------------------------------------------------------------------------------
10:53:31.528 INFO  [restartedMain] d.elements.tenants.TenantService         : DEFAULT: INSTALLING PLUGINS...
10:53:31.528 INFO  [restartedMain] d.elements.tenants.TenantService         : --------------------------------------------------------------------------------
10:53:31.529 INFO  [restartedMain] d.elements.core.ApplicationService       : DEFAULT: Executing 'dueuno.elements.core.onPluginInstall'...
10:53:31.532 INFO  [restartedMain] d.elements.core.ApplicationService       : ...done.
10:53:31.532 INFO  [restartedMain] d.elements.core.ApplicationService       :
10:53:31.544 INFO  [restartedMain] d.elements.core.ApplicationService       : Available languages [cs, da, de, en, es, fr, it, ja, nb, nl, pl, pt_br, pt_pt, ru, sk, sv, th, zh_cn]
10:53:31.544 INFO  [restartedMain] d.elements.core.ApplicationService       :
10:53:31.544 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
10:53:31.544 INFO  [restartedMain] d.elements.core.ApplicationService       : APPLICATION: STARTING UP...
10:53:31.544 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
10:53:31.545 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'dueuno.elements.core.beforeInit'...
10:53:31.586 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'com.example.init'...
10:53:31.586 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'dueuno.elements.core.afterInit'...
10:53:31.592 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
10:53:31.592 INFO  [restartedMain] d.elements.core.ApplicationService       : APPLICATION: STARTED.
10:53:31.593 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
10:53:31.593 INFO  [restartedMain] d.elements.core.ApplicationService       :
Grails application running at http://localhost:8080 in environment: development

HELP.md
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/

### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/

### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
out/
!**/src/main/**/out/
!**/src/test/**/out/

### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/

### VS Code ###
.vscode/

### Set the following to the application name
/demo/

dataSource:
  url: jdbc:h2:file:./demo/demo;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE

package com.example

import grails.gorm.MultiTenant
import org.grails.datastore.gorm.GormEntity

import java.time.LocalDate
import java.time.LocalDateTime

class TPerson implements GormEntity, MultiTenant<TPerson> {
    LocalDateTime dateCreated

    String firstname
    String lastname
    LocalDate birthdate

}

package com.example

import dueuno.elements.core.ApplicationService
import java.time.LocalDate

class BootStrap {

    ApplicationService applicationService
    PersonService personService

    def init = { servletContext ->
        applicationService.onDevInstall { String tenantId ->
            personService.create(
                    firstname: 'Felicity',
                    lastname: 'Green',
                    birthdate: LocalDate.of(2021, 1, 2),
            )
            personService.create(
                    firstname: 'Grace',
                    lastname: 'Blue',
                    birthdate: LocalDate.of(2021, 2, 1),
            )
            personService.create(
                    firstname: 'Joy',
                    lastname: 'Red',
                    birthdate: LocalDate.of(2021, 12, 21),
            )
        }

        applicationService.init {
            registerFeature(
                    controller: 'person',
                    icon: 'fa-user',
                    favourite: true,
            )
        }
    }

    def destroy = {
    }
}

$ ./gradlew bootRun

package com.example

import dueuno.elements.exceptions.ArgsException
import grails.gorm.DetachedCriteria
import grails.gorm.multitenancy.CurrentTenant
import javax.annotation.PostConstruct

@CurrentTenant
class PersonService {

    @PostConstruct
    void init() {
        // Executes only once when the application starts
    }

    private DetachedCriteria<TPerson> buildQuery(Map filterParams) {
        def query = TPerson.where {}

        if (filterParams.containsKey('id')) query = query.where { id == filterParams.id }
        if (filterParams.containsKey('birthdate')) query = query.where { birthdate == filterParams.birthdate }

        if (filterParams.find) {
            String search = filterParams.find.replaceAll('\\*', '%')
            query = query.where { 1 == 1
                || firstname =~ "%${search}%"
                || lastname =~ "%${search}%"
            }
        }

        // Add additional filters here

        return query
    }

    TPerson get(Serializable id) {
        // Add any relationships here (Eg. references to other DomainObjects or hasMany)
        Map fetch = [
                relationshipName: 'join',
        ]

        return buildQuery(id: id).get(fetch: fetch)
    }

    List<TPerson> list(Map filterParams = [:], Map fetchParams = [:]) {
        if (!fetchParams.sort) fetchParams.sort = [dateCreated: 'asc']

        // Add single-sided relationships here (Eg. references to other DomainObjects)
        // DO NOT add hasMany relationships, you are going to have troubles with pagination
        fetchParams.fetch = [
                relationshipName: 'join',
        ]

        def query = buildQuery(filterParams)
        return query.list(fetchParams)
    }

    Integer count(Map filterParams = [:]) {
        def query = buildQuery(filterParams)
        return query.count()
    }

    TPerson create(Map args = [:]) {
        if (args.failOnError == null) args.failOnError = false

        TPerson obj = new TPerson(args)
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    TPerson update(Map args = [:]) {
        Serializable id = ArgsException.requireArgument(args, 'id')
        if (args.failOnError == null) args.failOnError = false

        TPerson obj = get(id)
        obj.properties = args
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    void delete(Serializable id) {
        TPerson obj = get(id)
        obj.delete(flush: true, failOnError: true)
    }
}

package com.example

import dueuno.elements.contents.*
import dueuno.elements.controls.*
import dueuno.elements.core.ElementsController
import grails.validation.Validateable
import java.time.LocalDate

class PersonController implements ElementsController {

    PersonService personService

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            filters.with {
                addField(
                        class: DateField,
                        id: 'birthdate',
                        cols: 3,
                )
                addField(
                        class: TextField,
                        id: 'find',
                        cols: 9,
                )
            }
            sortable = [
                    lastname: 'asc',
            ]
            columns = [
                    'firstname',
                    'lastname',
                    'birthdate',
            ]
        }

        c.table.body = personService.list(c.table.filterParams, c.table.fetchParams)
        c.table.paginate = personService.count(c.table.filterParams)

        display content: c
    }

    private ContentForm buildForm(TPerson obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = TPerson
            addField(
                    class: TextField,
                    id: 'firstname',
            )
            addField(
                    class: TextField,
                    id: 'lastname',
            )
            addField(
                    class: DateField,
                    id: 'birthdate',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate() {
        def obj = personService.create(params)

        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def edit() {
        def obj = personService.get(params.id)
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit() {
        def obj = personService.update(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def onDelete() {
        try {
            personService.delete(params.id)
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

app.name=People Registry

shell.person=People
shell.person.help=Manage the People Registry

person.index.header.title=People
person.create.header.title=New Person
person.edit.header.title=Person
person.filters.birthdate=Birthdate
person.filters.find=Find
person.firstname=Firstname
person.lastname=Lastname
person.birthdate=Birth Date

app.name=Registro persone

shell.person=Persone
shell.person.help=Gestisci il registro persone

person.index.header.title=Persone
person.create.header.title=Nuova persona
person.edit.header.title=Persona
person.filters.birthdate=Nato il
person.filters.find=Trova
person.firstname=Nome
person.lastname=Cognome
person.birthdate=Nato il

$ ./gradlew bootRun

/demo/src/main/resources/deploy/public/brand
 - login-logo.png
 - login-background.jpg
 - logo.png
 - favicon.png
 - appicon.png

$ ./gradlew bootRun

class BootStrap {

    ApplicationService applicationService
    TenantPropertyService tenantPropertyService

    ...

    def init = { servletContext ->

        applicationService.onInstall { String tenantId ->
            tenantPropertyService.setString('PRIMARY_BACKGROUND_COLOR', '#018B84')
            tenantPropertyService.setNumber('PRIMARY_BACKGROUND_COLOR_ALPHA', 0.25)
            tenantPropertyService.setString('LOGIN_COPY', '2024 &copy; <a href="https://my-company.com" target="_blank">My Company</a><br/>Made in Italy')
        }

    ...

}

 __  __          ____
|  \/  |_   _   / ___|___  _ __ ___  _ __   __ _ _ __  _   _
| |\/| | | | | | |   / _ \| '_ ` _ \| '_ \ / _` | '_ \| | | |
| |  | | |_| | | |__| (_) | | | | | | |_) | (_| | | | | |_| |
|_|  |_|\__, |  \____\___/|_| |_| |_| .__/ \__,_|_| |_|\__, |
        |___/                       |_|                |___/

$ ./gradlew bootRun

18:47:30.769 INFO  [restartedMain] o.s.boot.SpringApplication               :
 __  __          ____
|  \/  |_   _   / ___|___  _ __ ___  _ __   __ _ _ __  _   _
| |\/| | | | | | |   / _ \| '_ ` _ \| '_ \ / _` | '_ \| | | |
| |  | | |_| | | |__| (_) | | | | | | |_) | (_| | | | | |_| |
|_|  |_|\__, |  \____\___/|_| |_| |_| .__/ \__,_|_| |_|\__, |
        |___/                       |_|                |___/


Configuring Spring Security Core ...
... finished configuring Spring Security Core

18:47:36.979 INFO  [restartedMain] d.elements.core.ApplicationService       : Available languages [en, it]
18:47:36.982 INFO  [restartedMain] d.elements.core.ApplicationService       :
18:47:36.982 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
18:47:36.982 INFO  [restartedMain] d.elements.core.ApplicationService       : APPLICATION: STARTING UP...
18:47:36.982 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
18:47:36.987 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'dueuno.elements.core.beforeInit'...
18:47:37.029 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'com.example.init'...
18:47:37.030 INFO  [restartedMain] d.elements.core.ApplicationService       : Executing 'dueuno.elements.core.afterInit'...
18:47:37.042 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
18:47:37.042 INFO  [restartedMain] d.elements.core.ApplicationService       : APPLICATION: STARTED.
18:47:37.042 INFO  [restartedMain] d.elements.core.ApplicationService       : --------------------------------------------------------------------------------
18:47:37.042 INFO  [restartedMain] d.elements.core.ApplicationService       :
Grails application running at http://localhost:8080 in environment: development

package com.example

import grails.gorm.MultiTenant
import org.grails.datastore.gorm.GormEntity
import java.time.LocalDate
import java.time.LocalDateTime

class TPerson implements GormEntity, MultiTenant<TPerson> {
LocalDateTime dateCreated

    String firstname
    String lastname
    LocalDate birthdate

    String address
    String city
    String postCode
    String state
    String country

    static constraints = {
        address nullable: true
        city nullable: true
        postCode nullable: true
        state nullable: true
        country nullable: true
    }
}

def index() {
    def c = createContent(ContentList)
    c.table.with {
        filters.with {
            addField(
                    class: DateField,
                    id: 'birthdate',
                    cols: 3,
            )
            addField(
                    class: TextField,
                    id: 'find',
                    cols: 9,
            )
        }
        sortable = [
                lastname: 'asc',
        ]
        columns = [
                'firstname',
                'lastname',
                'birthdate',
                'address',
                'city',
                'postCode',
                'state',
                'country',
        ]
    }

    c.table.body = personService.list(c.table.filterParams, c.table.fetchParams)
    c.table.paginate = personService.count(c.table.filterParams)

    display content: c
}

private ContentForm buildForm(TPerson obj = null) {
    def c = obj
        ? createContent(ContentEdit)
        : createContent(ContentCreate)

    c.form.with {
        validate = TPerson
        addField(
                class: TextField,
                id: 'firstname',
                cols: 6,
        )
        addField(
                class: TextField,
                id: 'lastname',
                cols: 6,
        )
        addField(
                class: DateField,
                id: 'birthdate',
                cols: 6,
        )
        addField(
                class: Separator,
                id: 's1',
                icon: 'fa-earth-americas',
                cols: 12,
        )
        addField(
                class: TextField,
                id: 'address',
                cols: 12,
        )
        addField(
                class: TextField,
                id: 'city',
                cols: 6,
        )
        addField(
                class: TextField,
                id: 'postCode',
                cols: 6,
        )
        addField(
                class: TextField,
                id: 'state',
                cols: 6,
        )
        addField(
                class: TextField,
                id: 'country',
                cols: 6,
        )
    }

    if (obj) {
        c.form.values = obj
    }

    return c
}

$ ./gradlew bootRun

package com.example

import grails.gorm.MultiTenant
import org.grails.datastore.gorm.GormEntity
import java.time.LocalDateTime

class TCompany implements GormEntity, MultiTenant<TCompany> {
LocalDateTime dateCreated
String name

    static hasMany = [
        emplyees: TPerson,
    ]
}

package com.example

import grails.gorm.MultiTenant
import org.grails.datastore.gorm.GormEntity
import java.time.LocalDate
import java.time.LocalDateTime

class TPerson implements GormEntity, MultiTenant<TPerson> {
LocalDateTime dateCreated

    String firstname
    String lastname
    LocalDate birthdate

    String address
    String city
    String postCode
    String state
    String country

    TCompany company
    static belongsTo = [
        company: TCompany,
    ]

    static constraints = {
        address nullable: true
        city nullable: true
        postCode nullable: true
        state nullable: true
        country nullable: true
    }
}

package com.example

import dueuno.elements.exceptions.ArgsException
import grails.gorm.DetachedCriteria
import grails.gorm.multitenancy.CurrentTenant

import javax.annotation.PostConstruct

@CurrentTenant
class CompanyService {

    @PostConstruct
    void init() {
        // Executes only once when the application starts
    }

    private DetachedCriteria<TCompany> buildQuery(Map filterParams) {
        def query = TCompany.where {}

        if (filterParams.containsKey('id')) query = query.where { id == filterParams.id }

        if (filterParams.find) {
            String search = filterParams.find.replaceAll('\\*', '%')
            query = query.where { 1 == 1
                || name =~ "%${search}%"
            }
        }

        // Add additional filters here

        return query
    }

    TCompany get(Serializable id) {
        // Add any relationships here (Eg. references to other DomainObjects or hasMany)
        Map fetch = [
                relationshipName: 'join',
        ]

        return buildQuery(id: id).get(fetch: fetch)
    }

    List<TCompany> list(Map filterParams = [:], Map fetchParams = [:]) {
        if (!fetchParams.sort) fetchParams.sort = [dateCreated: 'asc']

        // Add single-sided relationships here (Eg. references to other DomainObjects)
        // DO NOT add hasMany relationships, you are going to have troubles with pagination
        fetchParams.fetch = [
                relationshipName: 'join',
        ]

        def query = buildQuery(filterParams)
        return query.list(fetchParams)
    }

    Integer count(Map filterParams = [:]) {
        def query = buildQuery(filterParams)
        return query.count()
    }

    TCompany create(Map args = [:]) {
        if (args.failOnError == null) args.failOnError = false

        TCompany obj = new TCompany(args)
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    TCompany update(Map args = [:]) {
        Serializable id = ArgsException.requireArgument(args, 'id')
        if (args.failOnError == null) args.failOnError = false

        TCompany obj = get(id)
        obj.properties = args
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    void delete(Serializable id) {
        TCompany obj = get(id)
        obj.delete(flush: true, failOnError: true)
    }
}

package com.example

import dueuno.elements.exceptions.ArgsException
import grails.gorm.DetachedCriteria
import grails.gorm.multitenancy.CurrentTenant
import javax.annotation.PostConstruct

@CurrentTenant
class PersonService {

    @PostConstruct
    void init() {
        // Executes only once when the application starts
    }

    private DetachedCriteria<TPerson> buildQuery(Map filterParams) {
        def query = TPerson.where {}

        if (filterParams.containsKey('id')) query = query.where { id == filterParams.id }
        if (filterParams.containsKey('lastname')) query = query.where { lastname == filterParams.lastname }
        if (filterParams.containsKey('birthdate')) query = query.where { birthdate == filterParams.birthdate }
        if (filterParams.containsKey('company')) query = query.where { company.id == filterParams.company }

        if (filterParams.find) {
            String search = filterParams.find.replaceAll('\\*', '%')
            query = query.where { 1 == 1
                || firstname =~ "%${search}%"
                || lastname =~ "%${search}%"
            }
        }

        // Add additional filters here

        return query
    }

    TPerson get(Serializable id) {
        // Add any relationships here (Eg. references to other DomainObjects or hasMany)
        Map fetch = [
                company: 'join',
        ]

        return buildQuery(id: id).get(fetch: fetch)
    }

    List<TPerson> list(Map filterParams = [:], Map fetchParams = [:]) {
        if (!fetchParams.sort) fetchParams.sort = [dateCreated: 'asc']

        // Add single-sided relationships here (Eg. references to other DomainObjects)
        // DO NOT add hasMany relationships, you are going to have troubles with pagination
        fetchParams.fetch = [
                company: 'join',
        ]

        def query = buildQuery(filterParams)
        return query.list(fetchParams)
    }

    Integer count(Map filterParams = [:]) {
        def query = buildQuery(filterParams)
        return query.count()
    }

    TPerson create(Map args = [:]) {
        if (args.failOnError == null) args.failOnError = false

        TPerson obj = new TPerson(args)
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    TPerson update(Map args = [:]) {
        Serializable id = ArgsException.requireArgument(args, 'id')
        if (args.failOnError == null) args.failOnError = false

        TPerson obj = get(id)
        obj.properties = args
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    void delete(Serializable id) {
        TPerson obj = get(id)
        obj.delete(flush: true, failOnError: true)
    }
}

package com.example

import dueuno.elements.components.Table
import dueuno.elements.contents.ContentCreate
import dueuno.elements.contents.ContentEdit
import dueuno.elements.contents.ContentList
import dueuno.elements.controls.TextField
import dueuno.elements.core.ElementsController
import dueuno.elements.style.TextDefault

class CompanyController implements ElementsController {

    PersonService personService
    CompanyService companyService

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            filters.with {
                addField(
                        class: TextField,
                        id: 'find',
                        label: TextDefault.FIND,
                )
            }
            sortable = [
                    name: 'asc',
            ]
            columns = [
                    'name',
            ]
        }

        c.table.body = companyService.list(c.table.filterParams, c.table.fetchParams)
        c.table.paginate = companyService.count(c.table.filterParams)

        display content: c
    }

    private ContentForm buildForm(TCompany obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = TCompany
            addField(
                    class: TextField,
                    id: 'name',
            )
        }

        if (obj) {
            c.form.values = obj

            def table = c.addComponent(Table)
            table.with {
                rowActions = false
                rowHighlight = false
                columns = [
                        'firstname',
                        'lastname',
                        'country',
                ]
                body = personService.list(company: obj.id)
            }
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate() {
        def obj = companyService.create(params)

        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def edit() {
        def obj = companyService.get(params.id)
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit() {
        def obj = companyService.update(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def onDelete() {
        try {
            companyService.delete(params.id)
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

package com.example

import dueuno.elements.components.Separator
import dueuno.elements.contents.ContentCreate
import dueuno.elements.contents.ContentEdit
import dueuno.elements.contents.ContentList
import dueuno.elements.controls.DateField
import dueuno.elements.controls.Select
import dueuno.elements.controls.TextField
import dueuno.elements.core.ElementsController
import dueuno.elements.style.TextDefault

class PersonController implements ElementsController {

    PersonService personService
    CompanyService companyService

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            filters.with {
                addField(
                        class: DateField,
                        id: 'birthdate',
                        cols: 3,
                )
                addField(
                        class: TextField,
                        id: 'find',
                        label: TextDefault.FIND,
                        cols: 9,
                )
            }
            sortable = [
                    lastname: 'asc',
            ]
            columns = [
                    'company',
                    'firstname',
                    'lastname',
                    'birthdate',
                    'address',
                    'city',
                    'postCode',
                    'state',
                    'country',
            ]
        }

        c.table.body = personService.list(c.table.filterParams, c.table.fetchParams)
        c.table.paginate = personService.count(c.table.filterParams)

        display content: c
    }

    private ContentForm buildForm(TPerson obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = TPerson
            addField(
                    class: Select,
                    id: 'company',
                    optionsFromRecordset: companyService.list(),
                    cols: 12,
            )
            addField(
                    class: TextField,
                    id: 'firstname',
                    cols: 6,
            )
            addField(
                    class: TextField,
                    id: 'lastname',
                    cols: 6,
            )
            addField(
                    class: DateField,
                    id: 'birthdate',
                    cols: 6,
            )

            addField(
                    class: Separator,
                    id: 's1',
                    icon: 'fa-earth-americas',
                    cols: 12,
            )
            addField(
                    class: TextField,
                    id: 'address',
                    cols: 12,
            )
            addField(
                    class: TextField,
                    id: 'city',
                    cols: 6,
            )
            addField(
                    class: TextField,
                    id: 'postCode',
                    cols: 6,
            )
            addField(
                    class: TextField,
                    id: 'state',
                    cols: 6,
            )
            addField(
                    class: TextField,
                    id: 'country',
                    cols: 6,
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate() {
        def obj = personService.create(params)

        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def edit() {
        def obj = personService.get(params.id)
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit() {
        def obj = personService.update(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def onDelete() {
        try {
            personService.delete(params.id)
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

package com.example

import dueuno.elements.core.ApplicationService
import dueuno.elements.tenants.TenantPropertyService
import java.time.LocalDate

class BootStrap {

    ApplicationService applicationService
    TenantPropertyService tenantPropertyService
    PersonService personService
    CompanyService companyService

    def init = { servletContext ->

        applicationService.onInstall { String tenantId ->
            tenantPropertyService.setString('PRIMARY_BACKGROUND_COLOR', '#018B84')
            tenantPropertyService.setNumber('PRIMARY_BACKGROUND_COLOR_ALPHA', 0.25)
            tenantPropertyService.setString('LOGIN_COPY', '2024 &copy; <a href="https://my-company.com" target="_blank">My Company</a><br/>Made in Italy')
        }

        applicationService.onDevInstall { String tenantId ->

            def yourCompany = companyService.create(name: 'Your Company', failOnError: true)
            def theirCompany = companyService.create(name: 'Their Company', failOnError: true)

            personService.create(
                    company: yourCompany,
                    firstname: 'Felicity',
                    lastname: 'Green',
                    birthdate: LocalDate.of(2021, 1, 2),
                    failOnError: true,
            )
            personService.create(
                    company: yourCompany,
                    firstname: 'Grace',
                    lastname: 'Blue',
                    birthdate: LocalDate.of(2021, 2, 1),
                    failOnError: true,
            )
            personService.create(
                    company: theirCompany,
                    firstname: 'Joy',
                    lastname: 'Red',
                    birthdate: LocalDate.of(2021, 12, 21),
                    failOnError: true,
            )
        }

        applicationService.init {
            registerPrettyPrinter(TCompany, '${it.name}')
            registerFeature(
                    controller: 'person',
                    icon: 'fa-user',
                    favourite: true,
            )
            registerFeature(
                    controller: 'company',
                    icon: 'fa-briefcase',
            )
        }
    }

    def destroy = {
    }
}

$ ./gradlew bootRun

package com.example

import grails.gorm.MultiTenant
import org.grails.datastore.gorm.GormEntity

import java.time.LocalDateTime

class TBook implements GormEntity, MultiTenant<TBook> {

    String title
    String author
    String description
    Boolean taken

    static constraints = {
    }

}

package com.example

import dueuno.elements.exceptions.ArgsException
import grails.gorm.DetachedCriteria
import grails.gorm.multitenancy.CurrentTenant

import javax.annotation.PostConstruct

@CurrentTenant
class BookService {

    @PostConstruct
    void init() {
        // Executes only once when the application starts
    }

    private DetachedCriteria<TBook> buildQuery(Map filterParams) {
        def query = TBook.where {}

        if (filterParams.containsKey('id')) query = query.where { id == filterParams.id }

        if (filterParams.find) {
            String search = filterParams.find.replaceAll('\\*', '%')
            query = query.where { 1 == 1
                || title =~ "%${search}%"
                || author =~ "%${search}%"
                || description =~ "%${search}%"
            }
        }

        // Add additional filters here

        return query
    }

    TBook get(Serializable id) {
        // Add any relationships here (Eg. references to other DomainObjects or hasMany)
        Map fetch = [
                relationshipName: 'join',
        ]

        return buildQuery(id: id).get(fetch: fetch)
    }

    List<TBook> list(Map filterParams = [:], Map fetchParams = [:]) {
        if (!fetchParams.sort) fetchParams.sort = [dateCreated: 'asc']

        // Add single-sided relationships here (Eg. references to other DomainObjects)
        // DO NOT add hasMany relationships, you are going to have troubles with pagination
        fetchParams.fetch = [
                relationshipName: 'join',
        ]

        def query = buildQuery(filterParams)
        return query.list(fetchParams)
    }

    Integer count(Map filterParams = [:]) {
        def query = buildQuery(filterParams)
        return query.count()
    }

    TBook create(Map args = [:]) {
        if (args.failOnError == null) args.failOnError = false

        TBook obj = new TBook(args)
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    TBook update(Map args = [:]) {
        Serializable id = ArgsException.requireArgument(args, 'id')
        if (args.failOnError == null) args.failOnError = false

        TBook obj = get(id)
        obj.properties = args
        obj.save(flush: true, failOnError: args.failOnError)
        return obj
    }

    void delete(Serializable id) {
        TBook obj = get(id)
        obj.delete(flush: true, failOnError: true)
    }

    void take(Serializable id) {
        update(id: id, taken: true)
    }

    void giveBack(Serializable id) {
        update(id: id, taken: false)
    }
}

package com.example

import dueuno.elements.components.TableRow
import dueuno.elements.contents.ContentCreate
import dueuno.elements.contents.ContentEdit
import dueuno.elements.contents.ContentForm
import dueuno.elements.contents.ContentList
import dueuno.elements.controls.Checkbox
import dueuno.elements.controls.TextField
import dueuno.elements.core.ElementsController
import dueuno.elements.style.TextDefault

class BookController implements ElementsController {

    BookService bookService

    def index() {
        def c = createContent(ContentList)
        c.table.with {
            filters.with {
                fold = false
                addField(
                        class: TextField,
                        id: 'find',
                        label: TextDefault.FIND,
                )
            }
            sortable = [
                    title: 'asc',
                    author: 'asc',
            ]
            columns = [
                    'title',
                    'author',
                    'description',
                    'taken',
            ]

            groupActions.addAction(
                    action: 'onGiveBackAll',
                    submit: 'table',
                    icon: 'fa-regular fa-bookmark',
                    confirmMessage: 'book.index.confirm.give.back.all',
            )

            body.eachRow { TableRow row, Map values ->
                // Do not execute slow operations here to avoid slowing down the table rendering
                if (values.taken) {
                    row.actions.addAction(action: 'onGiveBack', icon: 'fa-regular fa-bookmark')
                } else {
                    row.actions.addAction(action: 'onTake', icon: 'fa-solid fa-bookmark')
                }
            }
        }

        c.table.body = bookService.list(c.table.filterParams, c.table.fetchParams)
        c.table.paginate = bookService.count(c.table.filterParams)

        display content: c
    }

    private ContentForm buildForm(TBook obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            validate = TBook
            addField(
                    class: TextField,
                    id: 'title',
            )
            addField(
                    class: TextField,
                    id: 'author',
            )
            addField(
                    class: TextField,
                    id: 'description',
            )
            addField(
                    class: Checkbox,
                    id: 'taken',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def onTake() {
        bookService.take(params.id)
        display action: 'index'
    }

    def onGiveBack() {
        bookService.giveBack(params.id)
        display action: 'index'
    }

    def onGiveBackAll() {
        List<Long> ids = params.rows.findAll { it.selected }*.id
        for (id in ids) {
            bookService.giveBack(id)
        }

        display action: 'index'
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate() {
        def obj = bookService.create(params)

        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def edit() {
        def obj = bookService.get(params.id)
        def c = buildForm(obj)
        display content: c, modal: true
    }

    def onEdit() {
        def obj = bookService.update(params)
        if (obj.hasErrors()) {
            display errors: obj
            return
        }

        display action: 'index'
    }

    def onDelete() {
        try {
            bookService.delete(params.id)
            display action: 'index'

        } catch (e) {
            display exception: e
        }
    }
}

    def init = { servletContext ->

        ...

        applicationService.onDevInstall { String tenantId ->

            ...

            bookService.create(
                    title: 'The Teachings of Don Juan',
                    author: 'Carlos Castaneda',
                    description: 'This is a nice fictional book',
                    borrowed: false,
                    failOnError: true,
            )
            bookService.create(
                    title: 'The Antipodes of the Mind',
                    author: 'Benny Shanon',
                    description: 'This is a nice scientific book',
                    borrowed: false,
                    failOnError: true,
            )
        }

        applicationService.init {

            ...

            registerFeature(
                    controller: 'book',
                    icon: 'fa-book',
            )
        }
    }

$ ./gradlew bootRun

c.table.with {
    columns = [
        'title',
        'author',
    ]
    actions.addAction(action: 'onTake')
    actions.addAction(action: 'onGiveBack')
}

c.table.with {
    columns = [
        'title',
        'author',
    ]

    body.eachRow { TableRow row, Map values ->
        if (values.borrowed) {
            row.actions.addAction(action: 'onGiveBack')
        } else {
            row.actions.addAction(action: 'onTake')
        }
    }
}

c.table.with {
    columns = [
        'title',
        'author',
    ]

    groupActions.addAction(action: 'onTake', submit: 'table')
    groupActions.addAction(action: 'onGiveBack', submit: 'table')
}

c.table.with {
    filters.with {
        addField(
            class: TextField,
            id: 'search',
        )
    }

    Map filters = c.table.filterParams (1)
    c.table.body = bookService.list(filters)
}

c.table.with {
    columns = [
        'title',
        'author',
    ]

    body = bookService.list(c.table.filterParams, c.table.fetchParams)
    paginate = bookService.count(c.table.filterParams)
}

def results = TBook.list(c.table.fetchParams)

package com.example

import dueuno.elements.components.Button
import dueuno.elements.contents.ContentForm
import dueuno.elements.controls.TextField
import dueuno.elements.core.ElementsController

class ButtonController implements ElementsController {

    def index() {
        def c = createContent(ContentForm)

        c.header.removeNextButton()

        c.form.with {
            addField(
                    class: TextField,
                    id: 'text',
                    defaultValue: 'You are the journey',
            )
            addField(
                    class: Button,
                    id: 'show',
                    action: 'onShow',
                    submit: ['form'],
                    primary: true,
                    cols: 4,
            )
            Button caseBtn = addField(
                    class: Button,
                    id: 'lowercase',
                    icon: 'fa-circle-down',
                    action: 'onLowercase',
                    submit: ['form'],
                    cols: 4,
            ).component
            caseBtn.addTailAction(
                    action: 'onUppercase',
                    submit: ['form'],
                    text: '',
                    icon: 'fa-circle-up',
            )

            Button capitalizeBtn = addField(
                    class: Button,
                    id: 'capitalize',
                    action: 'onCapitalize',
                    submit: ['form'],
                    cols: 4,
            ).component
            capitalizeBtn.addAction(
                    action: 'onUncapitalize',
                    submit: ['form'],
            )
            capitalizeBtn.addAction(
                    action: 'onQuote',
                    submit: ['form'],
            )
            capitalizeBtn.addAction(
                    action: 'onHighlight',
                    submit: ['form'],
            )
        }

        display content: c
    }

    def onShow() {
        String text = params.text
        display message: text
    }

    def onUppercase() {
        String text = params.text
        display message: text.toUpperCase()
    }

    def onLowercase() {
        String text = params.text
        display message: text.toLowerCase()
    }

    def onCapitalize() {
        String text = params.text
        display message: text.split(' ')*.capitalize().join(' ')
    }

    def onUncapitalize() {
        String text = params.text
        display message: text.split(' ')*.uncapitalize().join(' ')
    }

    def onQuote() {
        String text = params.text
        display message: "'${text}'"
    }

    def onHighlight() {
        String text = params.text
        display message: "- ${text} -"
    }
}

$ ./gradlew bootRun

dependencies {
    …​
    implementation "org.dueuno:elements-core:2.0-SNAPSHOT"
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->
        applicationService.init {
            // no-op (1)
        }
    }
}

spring:
  main:
    banner-mode: "log"

<logger name="org.springframework.boot.SpringApplication" level="INFO" />
<logger name="dueuno" level="INFO" />

class BootStrap {

    ApplicationService applicationService
    TenantPropertyService tenantPropertyService

    def init = { servletContext ->

        applicationService.onInstall { String tenantId ->
            tenantPropertyService.setString('SHELL_URL_MAPPING', '/admin')
            tenantPropertyService.setString('LOGIN_LANDING_URL', '/') (1)
            tenantPropertyService.setString('LOGOUT_LANDING_URL', '/') (2)

        }

    }
}

class WebsiteUrlMappings {

    static mappings = {
        "/"(controller: 'website')
        "/admin"(controller: 'shell') (1)
    }

}

class BootStrap {

    ApplicationService applicationService (1)

    def init = { servletContext ->

        applicationService.init { (2)
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.beforeInit {
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.afterInit {
            // ...
        }

    }
}

class BootStrap {

    SecurityService securityService (1)

    def init = { servletContext ->

        securityService.afterLogin {
            // ...
        }

    }
}

class BootStrap {

    SecurityService securityService (1)

    def init = { servletContext ->

        securityService.afterLogout {
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.onInstall { String tenantId -> (1)
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.onSystemInstall {
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.onPluginInstall { String tenantId ->
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.onDevInstall { String tenantId ->
            // ...
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext -> (1)

        applicationService.onUpdate('2021-01-03') { String tenantId ->
            println "${tenantId}: UPDATE N.2"
        }

        applicationService.onUpdate('2021-01-02') { String tenantId ->
            println "${tenantId}: UPDATE N.1"
        }

        applicationService.onUpdate('2021-01-05') { String tenantId ->
            println "${tenantId}: UPDATE N.4"
        }

        applicationService.onUpdate('2021-01-04') { String tenantId ->
            println "${tenantId}: UPDATE N.3"
        }
    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.init {
            registerPrettyPrinter(TProject, '${it.name}') (1)
            registerPrettyPrinter('PROJECT_ID', '${it.padLeft(4, "0")}') (2)
        }

    }
}

class BootStrap {

    ApplicationService applicationService
    SecurityService securityService

    def init = { servletContext ->

        applicationService.init {
            registerTransformer('USER_FULLNAME') { Object value ->
                return securityService.getUserByUsername(value).fullname
            }
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.init {
            registerCredits('Application Development', 'Francesco Piceghello', 'Gianluca Sartori')
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.init {
            registerFeature(
                    controller: 'book', (1)
                    action: 'index', (2)
                    icon: 'fa-book', (3)
                    authorities: ['ROLE_CAN_EDIT_BOOKS'] (4)
            )
            registerFeature(
                    controller: 'read',
                    icon: 'fa-glasses',
            )

            registerFeature(
                    controller: 'configuration', (5)
            )
            registerFeature(
                    parent: 'configuration', (6)
                    controller: 'authors',
                    icon: 'fa-user',
            )
            registerFeature(
                    parent: 'configuration',
                    controller: 'publishers',
                    icon: 'fa-user-shield',
            )
        }

    }
}

class BootStrap {

    ApplicationService applicationService

    def init = { servletContext ->

        applicationService.init {
            registerUserFeature(
                    controller: 'manual',
                    icon: 'fa-book',
                    targetNew: true,
            )
        }

    }
}

@Secured(['ROLE_CAN_EDIT_BOOKS']) (1)
class BookController implements ElementsController { (2)

    def index() {
        // will display a list of books
    }

    def create() { (3)
        // will display a form with book title and author
    }

    def onCreate() { (3)
        // will create the book record on the database
    }

    def edit() {
        // will display the details of a book
    }

    def onEdit() {
        // will update the book record on the database
    }

    def onDelete() {
        // will delete a book from the database
    }
}

@Secured(['ROLE_CAN_EDIT_BOOKS'])
class BookController implements ElementsController {

    BookService bookService (1)

    def index() {
        def c = createContent(ContentList) (2)

        c.table.with {
            columns = [
                    'title',
                    'author',
            ]
            body = bookService.list()
        }

        display content: c
    }

    private buildForm(Map obj = null) {
        def c = obj (3)
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            addField(
                    class: TextField,
                    id: 'title',
            )
            addField(
                    class: TextField,
                    id: 'author',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def edit() {
        def book = bookService.get(params.id)
        def c = buildForm(book)
        display content: c, modal: true
    }
}

class BookService {

    private static final data = [
            [id: 1, title: 'The Teachings of Don Juan', author: 'Carlos Castaneda', description: 'This is a nice fictional book'],
            [id: 2, title: 'The Antipodes of the Mind', author: 'Benny Shanon', description: 'This is a nice scientific book'],
    ]

    List<Map> list() {
        return data
    }

    Map get(Serializable id) {
        return data.find { it.id == id }
    }

    void create(Map record) {
        record.id = data.size() + 1
        data.add(record)
    }

    void update(Map record) {
        if (!record.id) throw new Exception("'id' required to update a record!")
        Map item = data.find { it.id == record.id }
        if (item) {
            item.title == record.title
            item.author = record.author
        }
    }

    void delete(Serializable id) {
        data.removeAll { it.id == id }
    }
}

class BookValidator implements Validateable {

    String title
    String author

    BookService bookService

    static constraints = {
        title validator: { Object val, BookValidator obj, Errors errors ->
            if (obj.bookService.getByTitle(val)) {
                errors.rejectValue('title', 'unique')
            }
        }
    }
}

class BookController implements ElementsController {

    BookService bookService

    def index() {
        def c = createContent(ContentList)

        c.table.with {
            columns = [
                    'title',
                    'author',
            ]
            body = bookService.list()
        }

        display content: c
    }

    private buildForm(Map obj = null) {
        def c = obj
                ? createContent(ContentEdit)
                : createContent(ContentCreate)

        c.form.with {
            addField(
                    class: TextField,
                    id: 'title',
            )
            addField(
                    class: TextField,
                    id: 'author',
            )
        }

        if (obj) {
            c.form.values = obj
        }

        return c
    }

    def create() {
        def c = buildForm()
        display content: c, modal: true
    }

    def onCreate(BookValidator obj) { (2)
        if (obj.hasErrors()) {
            display errors: obj (1)
            return
        }

        bookService.create(params)
        display action: 'index'
    }

    def edit() {
        def book = bookService.get(params.id)
        def c = buildForm(book)
        display content: c, modal: true
    }

    def onEdit(BookValidator obj) { (2)
        if (obj.hasErrors()) {
            display errors: obj (1)
            return
        }

        bookService.update(params)
        display action: 'index'
    }

    def onDelete() { (2)
        try {
            bookService.delete(params.id)
            display action: 'index'

        } catch (Exception e) {
            display exception: e
        }
    }
}

shell.book=Books
shell.read=Read
book.index.header.title=Books
book.create.header.title=New Book
book.edit.header.title=Book
book.title=Title
book.author=Author

shell.book=Libri
shell.read=Leggi
book.index.header.title=Libri
book.create.header.title=Nuovo libro
book.edit.header.title=Libro
book.title=Titolo
book.author=Autore