Dueuno Elements

| Running application…​

Configuring Spring Security Core …​
…​ finished configuring Spring Security Core

Grails application running at https://localhost:8080 in environment: development

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)
    }
}