Ignore:
Timestamp:
Jun 9, 2010, 12:46:22 PM (11 years ago)
Author:
roberth
Message:

Template editor is now able to add, edit, move and delete fields. Also fixed bug #90 (searching publications in IE didn't work because fetching XML from another domain was not allowed)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/studycapturing/TemplateEditorController.groovy

    r538 r544  
    1717import dbnp.studycapturing.*
    1818import cr.co.arquetipos.crypto.Blowfish
     19import grails.converters.*
    1920
    2021class TemplateEditorController {
     
    5152
    5253    /**
     54     * Shows an error page
     55     *
     56     * TODO: improve the error page
     57     */
     58    def error = {
     59        render( 'view': 'error' );
     60    }
     61
     62    /**
     63     * Adds a new template field using a AJAX call
     64         *
     65         * @param template      ID of the template to add a field to
     66         * @return                      JSON object with two entries:
     67         *                                              id: [id of this object]
     68         *                                              html: HTML to replace the contents of the LI-item that was updated.
     69         *                                      On error the method gives a HTTP response status 500 and the error
     70     */
     71    def addField = {
     72        // Search for the template
     73        def template = Template.get( params.template );
     74
     75        if( !template ) {
     76            response.status = 404;
     77            render 'Template not found';
     78            return;
     79        }
     80
     81                // Create the template field and add it to the template
     82                def templateField = new TemplateField( params );
     83        if (templateField.save(flush: true)) {
     84                        template.fields.add( templateField );
     85
     86                        def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
     87                        def output = [ id: templateField.id, html: html ];
     88                        render output as JSON;
     89
     90            //render '';
     91        } else {
     92            response.status = 500;
     93            render 'TemplateField could not be added because errors occurred.';
     94            return
     95        }
     96    }
     97
     98    /**
    5399     * Updates a selected template field using a AJAX call
     100         *
     101         * @param id    ID of the field to update
     102         * @return              JSON object with two entries:
     103         *                                      id: [id of this object]
     104         *                                      html: HTML to replace the contents of the LI-item that was updated.
     105         *                              On error the method gives a HTTP response status 500 and the error
    54106     */
    55107    def update = {
     
    73125        templateField.properties = params
    74126        if (!templateField.hasErrors() && templateField.save(flush: true)) {
    75             render '';
     127                        def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
     128                        def output = [ id: templateField.id, html: html ];
     129                        render output as JSON;
    76130        } else {
    77131            response.status = 500;
     
    82136
    83137    /**
    84      * Shows an error page
    85      *
    86      * TODO: improve the error page
    87      */
    88     def error = {
    89         render( 'view': 'error' );
     138     * Deletes a selected template field from the template using a AJAX call
     139         *
     140         * @param templateField ID of the field to update
     141         * @param template              ID of the template for which the field should be removed
     142         * @return                              Status code 200 on success, 500 otherwise
     143     */
     144    def delete = {
     145        // Search for the template
     146        def template = Template.get( params.template );
     147
     148        if( !template ) {
     149            response.status = 404;
     150            render 'Template not found';
     151            return;
     152        }
     153
     154        // Search for the template field
     155        def templateField = TemplateField.get( params.templateField );
     156        if( !templateField ) {
     157            response.status = 404;
     158            render 'TemplateField not found';
     159            return;
     160        }
     161
     162        // The template field should exist within the template
     163        if( !template.fields.contains( templateField ) ) {
     164            response.status = 404;
     165            render 'TemplateField not found within template';
     166            return;
     167        }
     168
     169                // Delete the field from this template
     170        def currentIndex = template.fields.indexOf( templateField );
     171        template.fields.remove( currentIndex );
     172                template.save();
     173                render '';
     174
     175                /*
     176                 *try {
     177                        templateField.delete(flush: true)
     178                        render "";
     179                        return;
     180                } catch (org.springframework.dao.DataIntegrityViolationException e) {
     181                        response.status = 500;
     182                        render "Templatefield not deleted: " + e.getMessage();
     183                        return;
     184                }
     185                */
    90186    }
    91187
     
    93189     * Moves a template field using a AJAX call
    94190     *
    95      *
     191         * @param template              ID of the template that contains this field
     192         * @param templateField ID of the templatefield to move
     193         * @param position              New index of the templatefield in the array. The index is 0-based.
     194         * @return                              JSON object with two entries:
     195         *                                                      id: [id of this object]
     196         *                                                      html: HTML to replace the contents of the LI-item that was updated.
     197         *                                              On error the method gives a HTTP response status 500 and the error
    96198     */
    97199    def move = {
     
    125227        template.fields.add( Integer.parseInt( params.position ), moveField );
    126228
    127         render "";
     229                def html = g.render( template: 'elements/liContent', model: [templateField: templateField, fieldTypes: TemplateFieldType.list()] );
     230                def output = [ id: templateField.id, html: html ];
     231                render output as JSON;
    128232    }
    129233
    130234    /**
    131235     * Checks whether a correct entity is given
     236         *
     237         * @return      boolean True if a correct entity is given. Returns false and raises an error otherwise
     238         * @see         error()
    132239     */
    133240    def _checkEntity = {
     
    137244        if( !entityName ) {
    138245            error();
    139             return;
     246            return false;
    140247        }
    141248
     
    145252        if( !entity ) {
    146253            error();
    147             return;
     254            retur; false
    148255        }
    149256
     
    154261    /**
    155262     * Checks whether the entity type is given and can be parsed
     263         *
     264         * @return      Name of the entity if parsing is succesful, false otherwise
    156265     */
    157266    def _parseEntityType() {
     
    181290
    182291    /**
    183      * Creates an object of the given entity. Returns false is the entity
    184      *   is not a subclass of TemplateEntity
     292     * Creates an object of the given entity.
     293         *
     294         * @return False if the entity is not a subclass of TemplateEntity
    185295     */
    186296    def _getEntity( entityName ) {
Note: See TracChangeset for help on using the changeset viewer.