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

c.table.with {
    filters.with {
        addField(
            class: Select,
            optionsFromRecordset: bookService.list(),
            prettyPrinter: 'BOOK',
            id: 'book',
            cols: 4,
        )
        addField(
            class: TextField,
            id: 'search',
            cols: 8,
        )
    }

    Map filters = c.table.filters.values (1)
}

c.form.with {
    grid = true
    addField(
        class: TextField,
        id: 'title',
        cols: 6,
    )
    addField(
        class: TextField,
        id: 'author',
        cols: 6,
    )
}

c.form.with {
    def addBookField = addField( (1)
        class: Button,
        id: 'addBook',
        action: 'addBook',
        submit: ['form'],
    )

    def button = addBookField.component
    button.addAction(controller: 'addAuthor')
}

c.form.with {
    addField( (1)
        class: Link,
        id: 'addBook',
        action: 'addBook',
        submit: ['form'],
        icon: 'fa-book',
    )
}

c.form.with {
    addField(
        class: Label,
        id: 'label',
        html: '<b>This is a bold statement!</b>',
        textAlign: TextAlign.END,
        textWrap: TextWrap.LINE_WRAP,
    )
}

def c = createContent(ContentList)
c.addComponent(
    class: KeyPress,
    id: 'keyPress',
    action: 'onKeyPress', (1)
)

c.form.addField(
    class: TextField,
    id: 'username',
    icon: 'fa-user',
)

c.form.with {
    addField(
        class: Checkbox,
        id: 'fullscreen',
        displayLabel: false,
        cols: 3,
    )
}

c.form.with {
    addField(
        class: Textarea,
        id: 'textarea',
        maxSize: 100,
        cols: 12,
        rows: 5,
    )
}

c.form.with {
    addField(
        class: QuantityField,
        id: 'quantity',
        defaultUnit: QuantityUnit.KM,
        availableUnits: quantityService.listAllUnits(),
    )
}

c.form.with {
    addField(
        class: MoneyField,
        id: 'salary',
        decimals: 0,
    )
}

c.form.with {
    addField(
        class: NumberField,
        id: 'number',
        min: -2,
        max: 10,
    )
}

c.form.with {
    addField(
        class: DateField,
        id: 'dateStart',
        min: LocalDate.now().minusDays(3),
        max: LocalDate.now().plusDays(3),
    )
}

c.form.with {
    addField(
        class: TimeField,
        id: 'time',
        min: LocalTime.now().minusHours(3),
        timeStep: 10,
    )
}

c.form.with {
    addField(
        class: DateTimeField,
        id: 'datetime',
        min: LocalDate.now().minusDays(3),
    )
}

c.form.with {
    addField(
        class: EmailField,
        id: 'email',
    )
}

c.form.with {
    addField(
        class: TelephoneField,
        id: 'telephone',
    )
}

c.form.with {
    addField(
        class: UrlField,
        id: 'url',
    )
}

c.form.with {
    addField(
        class: PasswordField,
        id: 'password',
    )
}

c.form.with {
    addField(
        class: HiddenField,
        id: 'hidden',
        value: 'This is not visible but it will be submitted',
    )
}