Ignore:
Timestamp:
Jan 21, 2011, 7:37:02 PM (10 years ago)
Author:
work@…
Message:
  • Resolved part of improvement #225
  • refactored the template model out of GSCF into the GDT (Grails Domain Templates) plugin version 0.0.1
  • still work needs to be done (move template editor into gdt, etcetera)
  • fix template owner
  • some methods are missing from Template, but most of it works
File:
1 edited

Legend:

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

    r1312 r1426  
    44 * Webflow driven template editor
    55 *
    6  * @author  Jeroen Wesbeek
    7  * @since       20100415
    8  * @package     studycapturing
     6 * @author Jeroen Wesbeek
     7 * @since 20100415
     8 * @package studycapturing
    99 *
    1010 * Revision information:
     
    1414 */
    1515package dbnp.studycapturing
    16 import dbnp.data.*
     16
     17import nl.grails.plugins.gdt.*
    1718import dbnp.studycapturing.*
     19
    1820
    1921import dbnp.authentication.AuthenticationService
     
    2628@Secured(['IS_AUTHENTICATED_REMEMBERED'])
    2729class TemplateEditorController {
    28     def entityName;
    29     def entity;
     30        def entityName;
     31        def entity;
    3032        def authenticationService
    3133
    3234        /**
    33     * Fires after every action and determines the layout of the page
    34     */
    35     def afterInterceptor = { model, modelAndView ->
    36       if ( params['standalone'] && params['standalone'] == 'true') {
    37         model.layout = 'main';
    38         model.extraparams = [ 'standalone': 'true' ] ;
    39       } else {
    40         model.layout = 'dialog';
    41         model.extraparams = [] ;
    42       }
    43     }
    44        
    45         /**
    46     * Study template editor page
    47         */
     35        * Fires after every action and determines the layout of the page
     36        */
     37        def afterInterceptor = { model, modelAndView ->
     38                if (params['standalone'] && params['standalone'] == 'true') {
     39                        model.layout = 'main';
     40                        model.extraparams = ['standalone': 'true'];
     41                } else {
     42                        model.layout = 'dialog';
     43                        model.extraparams = [];
     44                }
     45        }
     46
     47        /**
     48        * Study template editor page
     49         */
    4850        def study = {
    49             showEntity('dbnp.studycapturing.Study')
    50     }
    51 
    52         /**
    53     * Subject template editor page
    54         */
     51                showEntity('dbnp.studycapturing.Study')
     52        }
     53
     54        /**
     55        * Subject template editor page
     56         */
    5557        def subject = {
    56             showEntity('dbnp.studycapturing.Subject')
    57     }
    58 
    59         /**
    60     * Event template editor page
    61         */
     58                showEntity('dbnp.studycapturing.Subject')
     59        }
     60
     61        /**
     62        * Event template editor page
     63         */
    6264        def event = {
    63             showEntity('dbnp.studycapturing.Event')
    64     }
    65 
    66         /**
    67     * Sampling Event template editor page
    68         */
     65                showEntity('dbnp.studycapturing.Event')
     66        }
     67
     68        /**
     69        * Sampling Event template editor page
     70         */
    6971        def samplingEvent = {
    70             showEntity('dbnp.studycapturing.SamplingEvent')
    71     }
    72 
    73         /**
    74     * Event template editor page
    75         */
     72                showEntity('dbnp.studycapturing.SamplingEvent')
     73        }
     74
     75        /**
     76        * Event template editor page
     77         */
    7678        def sample = {
    77             showEntity('dbnp.studycapturing.Sample')
    78     }
    79 
    80         /**
    81     * Assay template editor page
    82         */
     79                showEntity('dbnp.studycapturing.Sample')
     80        }
     81
     82        /**
     83        * Assay template editor page
     84         */
    8385        def assay = {
    84             showEntity('dbnp.studycapturing.Assay')
    85     }
     86                showEntity('dbnp.studycapturing.Assay')
     87        }
    8688
    8789        /**
     
    9496                        // if a shared secret is defined, encrypt using that
    9597                        resultEntity = Blowfish.encryptBase64(
    96                                         targetEntity.toString(),
    97                                         grailsApplication.config.crypto.shared.secret
    98                                 )
     98                                targetEntity.toString(),
     99                                grailsApplication.config.crypto.shared.secret
     100                        )
    99101                }
    100102                else {
     
    105107                // redirect to template editor page of the specified entity
    106108                params.entity = resultEntity
    107                 redirect(action: "index", params:params)
    108         }
    109 
    110     /**
    111     * index closure
    112     */
    113     def index = {
    114         // Check whether a right entity is given
    115         if( !_checkEntity() ) {
     109                redirect(action: "index", params: params)
     110        }
     111
     112        /**
     113        * index closure
     114        */
     115        def index = {
     116                // Check whether a right entity is given
     117                if (!_checkEntity()) {
    116118                        return
    117119                }
    118120
    119         // fetch all templates for this entity
    120         def templates = Template.findAllByEntity(entity)
     121                // fetch all templates for this entity
     122                def templates = Template.findAllByEntity(entity)
    121123
    122124                // Generate a human readable entity name
    123                 def parts = entityName.tokenize( '.' );
    124                 def humanReadableEntity = parts[ parts.size() - 1 ];
    125 
    126         return [
    127             entity: entity,
    128             templates: templates,
    129             encryptedEntity: params.entity,
    130             humanReadableEntity: humanReadableEntity,
     125                def parts = entityName.tokenize('.');
     126                def humanReadableEntity = parts[parts.size() - 1];
     127
     128                return [
     129                        entity: entity,
     130                        templates: templates,
     131                        encryptedEntity: params.entity,
     132                        humanReadableEntity: humanReadableEntity,
    131133                        ontologies: params.ontologies
    132         ];
    133     }
    134 
    135     /**
    136     * compare two or more templates
    137     */
    138     def compare = {
    139         // Check whether a right entity is given
    140         if( !_checkEntity() ) {
     134                ];
     135        }
     136
     137        /**
     138        * compare two or more templates
     139        */
     140        def compare = {
     141                // Check whether a right entity is given
     142                if (!_checkEntity()) {
    141143                        return
    142144                }
    143145
    144         // fetch all templates for this entity
    145         def templates = Template.findAllByEntity(entity)
     146                // fetch all templates for this entity
     147                def templates = Template.findAllByEntity(entity)
    146148
    147149                // Find all available fields
    148                 def allFields = TemplateField.findAllByEntity( entity ).sort { a, b -> a.name <=> b.name }
     150                def allFields = TemplateField.findAllByEntity(entity).sort { a, b -> a.name <=> b.name }
    149151
    150152                // Generate a human readable entity name
    151                 def parts = entityName.tokenize( '.' );
    152                 def humanReadableEntity = parts[ parts.size() - 1 ];
    153 
    154         return [
    155             entity: entity,
    156             templates: templates,
     153                def parts = entityName.tokenize('.');
     154                def humanReadableEntity = parts[parts.size() - 1];
     155
     156                return [
     157                        entity: entity,
     158                        templates: templates,
    157159                        allFields: allFields,
    158             encryptedEntity: params.entity,
    159             humanReadableEntity: humanReadableEntity,
     160                        encryptedEntity: params.entity,
     161                        humanReadableEntity: humanReadableEntity,
    160162                        ontologies: params.ontologies,
    161163                        templateEntities: this.templateEntityList()
    162         ];
    163     }
     164                ];
     165        }
    164166
    165167        /**
     
    167169         */
    168170        def template = {
    169         // Check whether a right entity is given
    170         if( !_checkEntity() ) {
     171                // Check whether a right entity is given
     172                if (!_checkEntity()) {
    171173                        return
    172174                }
    173175
    174         // Check whether a template is selected. If not, redirect the user to the index
    175         def selectedTemplate = params.template;
    176         def template = null;
     176                // Check whether a template is selected. If not, redirect the user to the index
     177                def selectedTemplate = params.template;
     178                def template = null;
    177179                def domainFields = null;
    178180
    179         if( selectedTemplate ) {
    180             template = Template.get( selectedTemplate );
     181                if (selectedTemplate) {
     182                        template = Template.get(selectedTemplate);
    181183                        domainFields = template.entity.giveDomainFields();
    182         } else {
    183                         redirect(action:"index",params:[entity:params.entity])
    184                         return;
    185                 }
    186 
    187         // fetch all templates for this entity
    188         def templates = Template.findAllByEntity(entity)
     184                } else {
     185                        redirect(action: "index", params: [entity: params.entity])
     186                        return;
     187                }
     188
     189                // fetch all templates for this entity
     190                def templates = Template.findAllByEntity(entity)
    189191
    190192                // Generate a human readable entity name
    191                 def parts = entityName.tokenize( '.' );
    192                 def humanReadableEntity = parts[ parts.size() - 1 ];
     193                def parts = entityName.tokenize('.');
     194                def humanReadableEntity = parts[parts.size() - 1];
    193195
    194196                // Find all available fields
    195                 def allFields = TemplateField.findAllByEntity( entity ).sort { a, b -> a.name <=> b.name }
    196 
    197         return [
    198             entity: entity,
    199             templates: templates,
    200             encryptedEntity: params.entity,
    201             fieldTypes: TemplateFieldType.list(),
     197                def allFields = TemplateField.findAllByEntity(entity).sort { a, b -> a.name <=> b.name }
     198
     199                return [
     200                        entity: entity,
     201                        templates: templates,
     202                        encryptedEntity: params.entity,
     203                        fieldTypes: TemplateFieldType.list(),
    202204                        ontologies: Ontology.list(),
    203             humanReadableEntity: humanReadableEntity,
    204 
    205             template: template,
     205                        humanReadableEntity: humanReadableEntity,
     206
     207                        template: template,
    206208                        allFields: allFields,
    207209                        domainFields: domainFields
    208         ];
    209 
    210         }
    211 
    212 
    213     /**
    214      * Shows an error page
    215      *
    216      * TODO: improve the error page
    217      */
    218     def error = {
    219         render( 'view': 'error' );
    220     }
    221 
    222     /**
    223      * Creates a new template using a AJAX call
    224          *
    225          * @return                      JSON object with two entries:
    226          *                                              id: [id of this object]
    227          *                                              html: HTML to replace the contents of the LI-item that was updated.
    228          *                                      On error the method gives a HTTP response status 500 and the error
    229      */
    230    def createTemplate = {
     210                ];
     211
     212        }
     213
     214        /**
     215         * Shows an error page
     216         *
     217         * TODO: improve the error page
     218         */
     219        def error = {
     220                render('view': 'error');
     221        }
     222
     223        /**
     224         * Creates a new template using a AJAX call
     225         *
     226         * @return JSON object with two entries:
     227         *                                              id: [id of this object]
     228         *                                              html: HTML to replace the contents of the LI-item that was updated.
     229         *                                      On error the method gives a HTTP response status 500 and the error
     230         */
     231        def createTemplate = {
    231232                // Decode the entity
    232         if( !_checkEntity() ) {
     233                if (!_checkEntity()) {
    233234                        response.status = 500;
    234235                        render "Incorrect entity given";
     
    240241
    241242                // Create the template fields and add it to the template
    242                 def template = new Template( params );
    243         if (template.validate() && template.save(flush: true)) {
    244                         def html = g.render( template: 'elements/liTemplate', model: [template: template] );
    245                         def output = [ id: template.id, html: html ];
     243                def template = new Template(params);
     244                if (template.validate() && template.save(flush: true)) {
     245                        def html = g.render(template: 'elements/liTemplate', model: [template: template]);
     246                        def output = [id: template.id, html: html];
    246247                        render output as JSON;
    247         } else {
    248             response.status = 500;
    249             render 'Template could not be created because errors occurred.';
    250             return
    251         }
    252     }
    253 
    254     /**
    255     * Clones a template using a AJAX call
    256          *
    257          * @return                      JSON object with two entries:
    258          *                                              id: [id of this object]
    259          *                                              html: HTML of the contents of the LI-item that will be added.
    260          *                                      On error the method gives a HTTP response status 500 and the error
    261     */
    262      def cloneTemplate = {
    263         // Search for the template field
    264         def template = Template.get( params.id );
    265         if( !template ) {
    266             response.status = 404;
    267             render 'Template not found';
    268             return;
    269         }
     248                } else {
     249                        response.status = 500;
     250                        render 'Template could not be created because errors occurred.';
     251                        return
     252                }
     253        }
     254
     255        /**
     256        * Clones a template using a AJAX call
     257         *
     258         * @return JSON object with two entries:
     259         *                                              id: [id of this object]
     260         *                                              html: HTML of the contents of the LI-item that will be added.
     261         *                                      On error the method gives a HTTP response status 500 and the error
     262        */
     263        def cloneTemplate = {
     264                // Search for the template field
     265                def template = Template.get(params.id);
     266                if (!template) {
     267                        response.status = 404;
     268                        render 'Template not found';
     269                        return;
     270                }
    270271
    271272                // Create the template fields and add it to the template
    272                 def newTemplate = new Template( template, authenticationService.getLoggedInUser() );
    273         if (newTemplate.validate() && newTemplate.save(flush: true)) {
    274                         def html = g.render( template: 'elements/liTemplate', model: [template: newTemplate] );
    275                         def output = [ id: newTemplate.id, html: html ];
     273                def newTemplate = new Template(template, authenticationService.getLoggedInUser());
     274                if (newTemplate.validate() && newTemplate.save(flush: true)) {
     275                        def html = g.render(template: 'elements/liTemplate', model: [template: newTemplate]);
     276                        def output = [id: newTemplate.id, html: html];
    276277                        render output as JSON;
    277         } else {
    278             response.status = 500;
    279             render 'Template could not be cloned because errors occurred.';
    280             return
    281         }
    282     }
    283 
    284     /**
    285     * Updates a selected template using a AJAX call
    286          *
    287          * @param id    ID of the template to update
    288          * @return              JSON object with two entries:
    289          *                                      id: [id of this object]
    290          *                                      html: HTML to replace the contents of the LI-item that was updated.
    291          *                              On error the method gives a HTTP response status 500 and the error
    292     */
    293     def updateTemplate = {
    294         // Search for the template field
    295         def template = Template.get( params.id );
    296         if( !template ) {
    297             response.status = 404;
    298             render 'Template not found';
    299             return;
    300         }
    301 
    302         // Update the field if it is not updated in between
    303         if (params.version) {
    304             def version = params.version.toLong()
    305             if (template.version > version) {
    306                 response.status = 500;
    307                 render 'Template was updated while you were working on it. Please reload and try again.';
    308                 return
    309             }
    310         }
    311 
    312         template.properties = params
    313         if (!template.hasErrors() && template.save(flush: true)) {
    314                         def html = g.render( template: 'elements/liTemplate', model: [template: template] );
    315                         def output = [ id: template.id, html: html ];
     278                } else {
     279                        response.status = 500;
     280                        render 'Template could not be cloned because errors occurred.';
     281                        return
     282                }
     283        }
     284
     285        /**
     286        * Updates a selected template using a AJAX call
     287         *
     288         * @param id ID of the template to update
     289         * @return JSON object with two entries:
     290         *                                      id: [id of this object]
     291         *                                      html: HTML to replace the contents of the LI-item that was updated.
     292         *                              On error the method gives a HTTP response status 500 and the error
     293        */
     294        def updateTemplate = {
     295                // Search for the template field
     296                def template = Template.get(params.id);
     297                if (!template) {
     298                        response.status = 404;
     299                        render 'Template not found';
     300                        return;
     301                }
     302
     303                // Update the field if it is not updated in between
     304                if (params.version) {
     305                        def version = params.version.toLong()
     306                        if (template.version > version) {
     307                                response.status = 500;
     308                                render 'Template was updated while you were working on it. Please reload and try again.';
     309                                return
     310                        }
     311                }
     312
     313                template.properties = params
     314                if (!template.hasErrors() && template.save(flush: true)) {
     315                        def html = g.render(template: 'elements/liTemplate', model: [template: template]);
     316                        def output = [id: template.id, html: html];
    316317                        render output as JSON;
    317         } else {
    318             response.status = 500;
    319             render 'Template was not updated because errors occurred.';
    320             return
    321         }
    322     }
    323 
    324     /**
    325     * Deletes a template using a AJAX call
    326     *
    327          * @param template              ID of the template to move
    328          * @return                              JSON object with one entry:
    329          *                                                      id: [id of this object]
    330          *                                              On error the method gives a HTTP response status 500 and the error
    331     */
    332     def deleteTemplate = {
    333         // Search for the template field
    334         def  template = Template.get( params.template );
    335         if( !template ) {
    336             response.status = 404;
    337             render 'Template not found';
    338             return;
    339         }
    340 
    341         // Delete the template field
     318                } else {
     319                        response.status = 500;
     320                        render 'Template was not updated because errors occurred.';
     321                        return
     322                }
     323        }
     324
     325        /**
     326        * Deletes a template using a AJAX call
     327        *
     328         * @param template ID of the template to move
     329         * @return JSON object with one entry:
     330         *                                                      id: [id of this object]
     331         *                                              On error the method gives a HTTP response status 500 and the error
     332        */
     333        def deleteTemplate = {
     334                // Search for the template field
     335                def template = Template.get(params.template);
     336                if (!template) {
     337                        response.status = 404;
     338                        render 'Template not found';
     339                        return;
     340                }
     341
     342                // Delete the template field
    342343                try {
    343344                        template.delete(flush: true)
    344345
    345                         def output = [ id: template.id ];
     346                        def output = [id: template.id];
    346347                        render output as JSON;
    347348                }
    348349                catch (org.springframework.dao.DataIntegrityViolationException e) {
    349             response.status = 500;
    350             render 'Template could not be deleted: ' + e.getMessage();
    351                 }
    352     }
    353 
    354     /**
    355     * Creates a new template field using a AJAX call
    356          *
    357          * @param template      ID of the template to add a field to
    358          * @return                      JSON object with two entries:
    359          *                                              id: [id of this object]
    360          *                                              html: HTML to replace the contents of the LI-item that was updated.
    361          *                                      On error the method gives a HTTP response status 500 and the error
    362     */
    363     def createField = {
    364         // Search for the template
    365         def template = Template.get( params.template );
    366 
    367         if( !template ) {
    368             response.status = 404;
    369             render 'Template not found';
    370             return;
    371         }
     350                        response.status = 500;
     351                        render 'Template could not be deleted: ' + e.getMessage();
     352                }
     353        }
     354
     355        /**
     356        * Creates a new template field using a AJAX call
     357         *
     358         * @param template ID of the template to add a field to
     359         * @return JSON object with two entries:
     360         *                                              id: [id of this object]
     361         *                                              html: HTML to replace the contents of the LI-item that was updated.
     362         *                                      On error the method gives a HTTP response status 500 and the error
     363        */
     364        def createField = {
     365                // Search for the template
     366                def template = Template.get(params.template);
     367
     368                if (!template) {
     369                        response.status = 404;
     370                        render 'Template not found';
     371                        return;
     372                }
    372373
    373374                // Decode the entity, in order to set a good property
    374         if( !_checkEntity() ) {
     375                if (!_checkEntity()) {
    375376                        response.status = 500;
    376377                        render "Incorrect entity given";
     
    382383                // See whether this field already exists. It is checked by name, type and unit and entity
    383384                // The search is done using search by example (see http://grails.org/DomainClass+Dynamic+Methods, method find)
    384                 def uniqueParams = [ name: params.name, type: params.type, unit: params.unit, entity: params.entity ];
    385                 if( TemplateField.find( new TemplateField( uniqueParams ) ) ) {
     385                def uniqueParams = [name: params.name, type: params.type, unit: params.unit, entity: params.entity];
     386                if (TemplateField.find(new nl.grails.plugins.gdt.TemplateField(uniqueParams))) {
    386387                        response.status = 500;
    387388                        render "A field with this name, type and unit already exists.";
     
    391392                // See whether this exists as domain field. If it does, raise an error
    392393                def domainFields = template.entity.giveDomainFields()
    393                 if( domainFields.find { it.name.toLowerCase() == params.name.toLowerCase() } ) {
     394                if (domainFields.find { it.name.toLowerCase() == params.name.toLowerCase() }) {
    394395                        response.status = 500;
    395396                        render "All templates for entity " + template.entity + " contain a domain field with name " + params.name + ". You can not create a field with this name.";;
     
    398399
    399400                // If this field is type stringlist, we have to prepare the parameters
    400                 if( params.type.toString() == 'STRINGLIST' ) {
     401                if (params.type.toString() == 'STRINGLIST') {
    401402                        def listEntries = [];
    402403                        params.listEntries.eachLine {
     
    406407                                def name = it.trim();
    407408
    408                                 def listitem = new TemplateFieldListItem( name: name )
    409                                 listEntries.add( listitem );
     409                                def listitem = new nl.grails.plugins.gdt.TemplateFieldListItem(name: name)
     410                                listEntries.add(listitem);
    410411                        }
    411412
    412413                        params.listEntries = listEntries;
    413414                } else {
    414                         params.remove( 'listEntries' );
     415                        params.remove('listEntries');
    415416                }
    416417
    417418                // If this field isnot a ontologyterm, we should remove the ontologies
    418                 if( params.type.toString() != 'ONTOLOGYTERM' ) {
    419                         params.remove( 'ontologies' );
     419                if (params.type.toString() != 'ONTOLOGYTERM') {
     420                        params.remove('ontologies');
    420421                }
    421422
    422423                // Create the template field and add it to the template
    423                 def templateField = new TemplateField( params );
    424         if (templateField.save(flush: true)) {
    425 
    426                         def html = g.render( template: 'elements/available', model: [templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()] );
    427                         def output = [ id: templateField.id, html: html ];
     424                def templateField = new nl.grails.plugins.gdt.TemplateField(params);
     425                if (templateField.save(flush: true)) {
     426
     427                        def html = g.render(template: 'elements/available', model: [templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()]);
     428                        def output = [id: templateField.id, html: html];
    428429                        render output as JSON;
    429430
    430             //render '';
    431         } else {
    432             response.status = 500;
    433             render 'TemplateField could not be created because errors occurred.';
    434             return
    435         }
    436     }
    437 
    438     /**
    439     * Updates a selected template field using a AJAX call
    440          *
    441          * @param id    ID of the field to update
    442          * @return              JSON object with two entries:
    443          *                                      id: [id of this object]
    444          *                                      html: HTML to replace the contents of the LI-item that was updated.
    445          *                              On error the method gives a HTTP response status 500 and the error
    446     */
    447     def updateField = {
    448         // Search for the template field
    449         def templateField = TemplateField.get( params.id );
    450         if( !templateField ) {
    451             response.status = 404;
    452             render 'TemplateField not found';
    453             return;
    454         }
    455 
    456         // Update the field if it is not updated in between
    457         if (params.version) {
    458             def version = params.version.toLong()
    459             if (templateField.version > version) {
    460                 response.status = 500;
    461                 render 'TemplateField was updated while you were working on it. Please reload and try again.';
    462                 return
    463             }
    464         }
     431                        //render '';
     432                } else {
     433                        response.status = 500;
     434                        render 'TemplateField could not be created because errors occurred.';
     435                        return
     436                }
     437        }
     438
     439        /**
     440        * Updates a selected template field using a AJAX call
     441         *
     442         * @param id ID of the field to update
     443         * @return JSON object with two entries:
     444         *                                      id: [id of this object]
     445         *                                      html: HTML to replace the contents of the LI-item that was updated.
     446         *                              On error the method gives a HTTP response status 500 and the error
     447        */
     448        def updateField = {
     449                // Search for the template field
     450                def templateField = TemplateField.get(params.id);
     451                if (!templateField) {
     452                        response.status = 404;
     453                        render 'TemplateField not found';
     454                        return;
     455                }
     456
     457                // Update the field if it is not updated in between
     458                if (params.version) {
     459                        def version = params.version.toLong()
     460                        if (templateField.version > version) {
     461                                response.status = 500;
     462                                render 'TemplateField was updated while you were working on it. Please reload and try again.';
     463                                return
     464                        }
     465                }
    465466
    466467                // If this field is type stringlist or ontology, we have to prepare the parameters
     
    469470                // In that case, only never-used items can be removed or changed and items can be added. If that is the case
    470471                // params.is_disabled is true and we should combine listEntries and extraListEntries with the items already in use.
    471                 if( params.type.toString() == 'STRINGLIST' || ( templateField.type == TemplateFieldType.STRINGLIST && params.is_disabled) ) {
     472                if (params.type.toString() == 'STRINGLIST' || (templateField.type == TemplateFieldType.STRINGLIST && params.is_disabled)) {
    472473                        def listEntryLines = "";
    473474                        def listEntries = [];
    474475
    475                         if( params.is_disabled ) {
     476                        if (params.is_disabled) {
    476477                                listEntries = templateField.getUsedListEntries();
    477478                        }
    478479
    479                         if( params.listEntries ) {
     480                        if (params.listEntries) {
    480481                                listEntryLines = params.listEntries;
    481                                
     482
    482483                                listEntryLines.eachLine {
    483484                                        // We don't search for a listitem that might already exist,
     
    489490                                        def c = TemplateFieldListItem.createCriteria()
    490491                                        def listitem = c.get {
    491                                                 eq( "name", name )
    492                                                 eq( "parent", templateField)
     492                                                eq("name", name)
     493                                                eq("parent", templateField)
    493494                                        }
    494                                         if( !listitem ) {
    495                                                 listitem = new TemplateFieldListItem( name: name )
     495                                        if (!listitem) {
     496                                                listitem = new nl.grails.plugins.gdt.TemplateFieldListItem(name: name)
    496497                                        }
    497498
    498499                                        // Prevent using the same list entry twice
    499                                         if( !listEntries.contains( listitem ) )
    500                                                 listEntries.add( listitem );
     500                                        if (!listEntries.contains(listitem))
     501                                        listEntries.add(listitem);
    501502                                }
    502503                        }
     
    505506                        params.listEntries = listEntries;
    506507                } else {
    507                         params.remove( 'listEntries' );
     508                        params.remove('listEntries');
    508509                }
    509510
     
    512513                // In that case, only never-used items can be removed or changed and items can be added. If that is the case
    513514                // params.is_disabled is true and we should combine ontologies with the ontologies already in use.
    514                 if( ( params.type.toString() == 'ONTOLOGYTERM' || ( templateField.type == TemplateFieldType.ONTOLOGYTERM && params.is_disabled ) ) && params.ontologies ) {
     515                if ((params.type.toString() == 'ONTOLOGYTERM' || (templateField.type == TemplateFieldType.ONTOLOGYTERM && params.is_disabled)) && params.ontologies) {
    515516                        def usedOntologies = [];
    516517
    517                         if( params.is_disabled ) {
     518                        if (params.is_disabled) {
    518519                                usedOntologies = templateField.getUsedOntologies();
    519520                        }
    520521
    521                         if( params.ontologies ) {
     522                        if (params.ontologies) {
    522523                                def ontologies = params.ontologies;
    523        
    524                                 params.ontologies = usedOntologies + Ontology.getAll( ontologies.collect { Integer.parseInt( it ) } );
    525                         }
    526 
    527                 } else {
    528                         params.remove( 'ontologies' );
     524
     525                                params.ontologies = usedOntologies + Ontology.getAll(ontologies.collect { Integer.parseInt(it) });
     526                        }
     527
     528                } else {
     529                        params.remove('ontologies');
    529530                }
    530531
    531532                // A field that is already used in one or more templates, but is not filled everywhere,
    532533                // can not be set to required
    533                 if( params.required ) {
    534                         if( !templateField.isFilledInAllObjects() ) {
     534                if (params.required) {
     535                        if (!templateField.isFilledInAllObjects()) {
    535536                                response.status = 500;
    536537                                render "A field can only be marked as required if all objects using this field have a value for the field."
     
    543544
    544545                templateField.validate();
    545                
    546 
    547         if (!templateField.hasErrors() && templateField.save(flush: true)) {
     546
     547
     548                if (!templateField.hasErrors() && templateField.save(flush: true)) {
    548549
    549550                        // Remove all orphaned list items, because grails doesn't handle it for us
    550                         TemplateFieldListItem.findAllByParent( templateField ).each {
    551                                 if( !params.listEntries.contains( it ) ) {
    552                                         templateField.removeFromListEntries( it );
     551                        TemplateFieldListItem.findAllByParent(templateField).each {
     552                                if (!params.listEntries.contains(it)) {
     553                                        templateField.removeFromListEntries(it);
    553554                                        it.delete();
    554555                                }
     
    557558                        // Select the template to use for the HTML output
    558559                        def renderTemplate = 'elements/available';
    559                         if( params.renderTemplate == 'selected' ) {
     560                        if (params.renderTemplate == 'selected') {
    560561                                renderTemplate = 'elements/selected';
    561562                        }
     
    563564                        // Selected fields should have a template given
    564565                        def template = null;
    565                         if( params.templateId )
    566                                 template = Template.findById( params.templateId );
    567                        
    568                         def html = g.render( template: renderTemplate, model: [template: template, templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()] );
    569                         def output = [ id: templateField.id, html: html ];
     566                        if (params.templateId)
     567                        template = Template.findById(params.templateId);
     568
     569                        def html = g.render(template: renderTemplate, model: [template: template, templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()]);
     570                        def output = [id: templateField.id, html: html];
    570571                        render output as JSON;
    571         } else {
    572             response.status = 500;
    573             render 'TemplateField was not updated because errors occurred. Please contact the system administrator';
    574             return
    575         }
    576     }
    577 
    578     /**
    579     * Deletes a template field using a AJAX call
    580     *
    581          * @param templateField ID of the templatefield to move
    582          * @return                              JSON object with one entry:
    583          *                                                      id: [id of this object]
    584          *                                              On error the method gives a HTTP response status 500 and the error
    585     */
    586     def deleteField = {
    587         // Search for the template field
    588         def  templateField = TemplateField.get( params.templateField );
    589         if( !templateField ) {
    590             response.status = 404;
    591             render 'TemplateField not found';
    592             return;
    593         }
    594 
    595         // Delete the template field
     572                } else {
     573                        response.status = 500;
     574                        render 'TemplateField was not updated because errors occurred. Please contact the system administrator';
     575                        return
     576                }
     577        }
     578
     579        /**
     580        * Deletes a template field using a AJAX call
     581        *
     582         * @param templateField ID of the templatefield to move
     583         * @return JSON object with one entry:
     584         *                                                      id: [id of this object]
     585         *                                              On error the method gives a HTTP response status 500 and the error
     586        */
     587        def deleteField = {
     588                // Search for the template field
     589                def templateField = TemplateField.get(params.templateField);
     590                if (!templateField) {
     591                        response.status = 404;
     592                        render 'TemplateField not found';
     593                        return;
     594                }
     595
     596                // Delete the template field
    596597                try {
    597598                        templateField.delete(flush: true)
    598599
    599                         def output = [ id: templateField.id ];
     600                        def output = [id: templateField.id];
    600601                        render output as JSON;
    601602                }
    602603                catch (org.springframework.dao.DataIntegrityViolationException e) {
    603             response.status = 500;
    604             render 'TemplateField could not be deleted: ' + e.getMessage();
    605                 }
    606     }
    607 
    608     /**
    609     * Adds a new template field to a template using a AJAX call
    610          *
    611          * @param template      ID of the template to add a field to
    612          * @return                      JSON object with two entries:
    613          *                                              id: [id of this object]
    614          *                                              html: HTML to replace the contents of the LI-item that was updated.
    615          *                                      On error the method gives a HTTP response status 404 or 500 and the error
    616     */
    617     def addField = {
    618         // Search for the template
    619         def template = Template.get( params.template );
    620 
    621         if( !template ) {
    622             response.status = 404;
    623             render 'Template not found';
    624             return;
    625         }
    626 
    627         // Search for the template field
    628         def templateField = TemplateField.get( params.templateField );
    629         if( !templateField ) {
    630             response.status = 404;
    631             render 'TemplateField does not exist';
    632             return;
    633         }
    634 
    635         // The template field should exist within the template
    636         if( template.fields.contains( templateField ) ) {
    637             response.status = 500;
    638             render 'TemplateField is already found within template';
    639             return;
    640         }
     604                        response.status = 500;
     605                        render 'TemplateField could not be deleted: ' + e.getMessage();
     606                }
     607        }
     608
     609        /**
     610        * Adds a new template field to a template using a AJAX call
     611         *
     612         * @param template ID of the template to add a field to
     613         * @return JSON object with two entries:
     614         *                                              id: [id of this object]
     615         *                                              html: HTML to replace the contents of the LI-item that was updated.
     616         *                                      On error the method gives a HTTP response status 404 or 500 and the error
     617        */
     618        def addField = {
     619                // Search for the template
     620                def template = Template.get(params.template);
     621
     622                if (!template) {
     623                        response.status = 404;
     624                        render 'Template not found';
     625                        return;
     626                }
     627
     628                // Search for the template field
     629                def templateField = TemplateField.get(params.templateField);
     630                if (!templateField) {
     631                        response.status = 404;
     632                        render 'TemplateField does not exist';
     633                        return;
     634                }
     635
     636                // The template field should exist within the template
     637                if (template.fields.contains(templateField)) {
     638                        response.status = 500;
     639                        render 'TemplateField is already found within template';
     640                        return;
     641                }
    641642
    642643                // If the template is in use, only non-required fields can be added
    643                 if( template.inUse() && templateField.required ) {
     644                if (template.inUse() && templateField.required) {
    644645                        response.status = 500;
    645646                        render 'Only non-required fields can be added to templates that are in use.'
     
    648649
    649650                // All field names within a template should be unique
    650                 if( template.fields.find { it.name.toLowerCase() == templateField.name.toLowerCase() } ) {
     651                if (template.fields.find { it.name.toLowerCase() == templateField.name.toLowerCase() }) {
    651652                        response.status = 500;
    652653                        render 'This template already contains a field with name ' + templateField.name + '. Field names should be unique within a template.'
     
    654655                }
    655656
    656                 if( !params.position || Integer.parseInt( params.position ) == -1) {
    657                         template.fields.add( templateField )
    658                 } else {
    659                         template.fields.add( Integer.parseInt( params.position ), templateField )
    660                 }
    661 
    662             if (!template.validate()) {
    663                     response.status = 500;
    664                     template.errors.each { render it}
    665             }
    666             template.save(flush:true);
    667 
    668                 def html = g.render( template: 'elements/selected', model: [templateField: templateField, template: template, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()] );
    669                 def output = [ id: templateField.id, html: html ];
     657                if (!params.position || Integer.parseInt(params.position) == -1) {
     658                        template.fields.add(templateField)
     659                } else {
     660                        template.fields.add(Integer.parseInt(params.position), templateField)
     661                }
     662
     663                if (!template.validate()) {
     664                        response.status = 500;
     665                        template.errors.each { render it}
     666                }
     667                template.save(flush: true);
     668
     669                def html = g.render(template: 'elements/selected', model: [templateField: templateField, template: template, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()]);
     670                def output = [id: templateField.id, html: html];
    670671                render output as JSON;
    671     }
    672 
    673     /**
    674     * Removes a selected template field from the template using a AJAX call
    675          *
    676          * @param templateField ID of the field to update
    677          * @param template              ID of the template for which the field should be removed
    678          * @return                              JSON object with two entries:
    679          *                                                      id: [id of this object]
    680          *                                                      html: HTML to replace the contents of the LI-item that was updated.
    681          *                                              On error the method gives a HTTP response status 404 or 500 and the error
    682     */
    683     def removeField = {
    684         // Search for the template
    685         def template = Template.get( params.template );
    686 
    687         if( !template ) {
    688             response.status = 404;
    689             render 'Template not found';
    690             return;
    691         }
    692 
    693         // Search for the template field
    694         def templateField = TemplateField.get( params.templateField );
    695         if( !templateField ) {
    696             response.status = 404;
    697             render 'TemplateField not found';
    698             return;
    699         }
    700 
    701         // The template field should exist within the template
    702         if( !template.fields.contains( templateField ) ) {
    703             response.status = 404;
    704             render 'TemplateField not found within template';
    705             return;
    706         }
     672        }
     673
     674        /**
     675        * Removes a selected template field from the template using a AJAX call
     676         *
     677         * @param templateField ID of the field to update
     678         * @param template ID of the template for which the field should be removed
     679         * @return JSON object with two entries:
     680         *                                                      id: [id of this object]
     681         *                                                      html: HTML to replace the contents of the LI-item that was updated.
     682         *                                              On error the method gives a HTTP response status 404 or 500 and the error
     683        */
     684        def removeField = {
     685                // Search for the template
     686                def template = Template.get(params.template);
     687
     688                if (!template) {
     689                        response.status = 404;
     690                        render 'Template not found';
     691                        return;
     692                }
     693
     694                // Search for the template field
     695                def templateField = TemplateField.get(params.templateField);
     696                if (!templateField) {
     697                        response.status = 404;
     698                        render 'TemplateField not found';
     699                        return;
     700                }
     701
     702                // The template field should exist within the template
     703                if (!template.fields.contains(templateField)) {
     704                        response.status = 404;
     705                        render 'TemplateField not found within template';
     706                        return;
     707                }
    707708
    708709                // If the template is in use, field can not be removed
    709                 if( templateField.isFilledInTemplate(template) ) {
     710                if (templateField.isFilledInTemplate(template)) {
    710711                        response.status = 500;
    711712                        render 'Fields can not be removed from a template if it has been filled somewhere.'
     
    714715
    715716                // Delete the field from this template
    716         def currentIndex = template.fields.indexOf( templateField );
    717         template.fields.remove( currentIndex );
    718                 template.save(flush:true);
    719 
    720 
    721                 def html = g.render( template: 'elements/available', model: [templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()] );
    722                 def output = [ id: templateField.id, html: html ];
     717                def currentIndex = template.fields.indexOf(templateField);
     718                template.fields.remove(currentIndex);
     719                template.save(flush: true);
     720
     721
     722                def html = g.render(template: 'elements/available', model: [templateField: templateField, ontologies: Ontology.list(), fieldTypes: TemplateFieldType.list()]);
     723                def output = [id: templateField.id, html: html];
    723724                render output as JSON;
    724     }
    725 
    726     /**
    727     * Moves a template field using a AJAX call
    728     *
    729          * @param template              ID of the template that contains this field
    730          * @param templateField ID of the templatefield to move
    731          * @param position              New index of the templatefield in the array. The index is 0-based.
    732          * @return                              JSON object with two entries:
    733          *                                                      id: [id of this object]
    734          *                                                      html: HTML to replace the contents of the LI-item that was updated.
    735          *                                              On error the method gives a HTTP response status 500 and the error
    736     */
    737     def moveField = {
    738         // Search for the template
    739         def template = Template.get( params.template );
    740 
    741         if( !template ) {
    742             response.status = 404;
    743             render 'Template not found';
    744             return;
    745         }
    746 
    747         // Search for the template field
    748         def  templateField = TemplateField.get( params.templateField );
    749         if( !templateField ) {
    750             response.status = 404;
    751             render 'TemplateField not found';
    752             return;
    753         }
    754 
    755         // The template field should exist within the template
    756         if( !template.fields.contains( templateField ) ) {
    757             response.status = 404;
    758             render 'TemplateField not found within template';
    759             return;
    760         }
    761 
    762         // Move the item
    763         def currentIndex = template.fields.indexOf( templateField );
    764         def moveField = template.fields.remove( currentIndex );
    765 
    766         template.fields.add( Integer.parseInt( params.position ), moveField );
    767                 template.save(flush:true);
    768 
    769                 def html = g.render( template: 'elements/selected', model: [templateField: templateField, template: template, fieldTypes: TemplateFieldType.list()] );
    770                 def output = [ id: templateField.id, html: html ];
     725        }
     726
     727        /**
     728        * Moves a template field using a AJAX call
     729        *
     730         * @param template ID of the template that contains this field
     731         * @param templateField ID of the templatefield to move
     732         * @param position New index of the templatefield in the array. The index is 0-based.
     733         * @return JSON object with two entries:
     734         *                                                      id: [id of this object]
     735         *                                                      html: HTML to replace the contents of the LI-item that was updated.
     736         *                                              On error the method gives a HTTP response status 500 and the error
     737        */
     738        def moveField = {
     739                // Search for the template
     740                def template = Template.get(params.template);
     741
     742                if (!template) {
     743                        response.status = 404;
     744                        render 'Template not found';
     745                        return;
     746                }
     747
     748                // Search for the template field
     749                def templateField = TemplateField.get(params.templateField);
     750                if (!templateField) {
     751                        response.status = 404;
     752                        render 'TemplateField not found';
     753                        return;
     754                }
     755
     756                // The template field should exist within the template
     757                if (!template.fields.contains(templateField)) {
     758                        response.status = 404;
     759                        render 'TemplateField not found within template';
     760                        return;
     761                }
     762
     763                // Move the item
     764                def currentIndex = template.fields.indexOf(templateField);
     765                def moveField = template.fields.remove(currentIndex);
     766
     767                template.fields.add(Integer.parseInt(params.position), moveField);
     768                template.save(flush: true);
     769
     770                def html = g.render(template: 'elements/selected', model: [templateField: templateField, template: template, fieldTypes: TemplateFieldType.list()]);
     771                def output = [id: templateField.id, html: html];
    771772                render output as JSON;
    772     }
     773        }
    773774
    774775        /**
    775776         * Checks how many template use a specific template field
    776777         *
    777          * @param       id      ID of the template field
    778          * @return      int     Number of uses
     778         * @param id ID of the template field
     779         * @return int  Number of uses
    779780         */
    780781        def numFieldUses = {
    781         // Search for the template field
    782         def  templateField = TemplateField.get( params.id );
    783         if( !templateField ) {
    784             response.status = 404;
    785             render 'TemplateField not found';
    786             return;
    787         }
     782                // Search for the template field
     783                def templateField = TemplateField.get(params.id);
     784                if (!templateField) {
     785                        response.status = 404;
     786                        render 'TemplateField not found';
     787                        return;
     788                }
    788789
    789790                render templateField.numUses();
     
    793794         * Adds a ontolgy based on the ID given
    794795         *
    795          * @param       ncboID
    796          * @return      JSON    Ontology object
     796         * @param ncboID
     797         * @return JSON Ontology object
    797798         */
    798799        def addOntologyById = {
    799800                def id = params.ncboID;
    800801
    801                 if( !id ) {
     802                if (!id) {
    802803                        response.status = 500;
    803804                        render 'No ID given'
     
    805806                }
    806807
    807                 if( Ontology.findByNcboId( Integer.parseInt(  id ) ) ) {
     808                if (Ontology.findByNcboId(Integer.parseInt(id))) {
    808809                        response.status = 500;
    809810                        render 'This ontology was already added to the system';
     
    814815
    815816                try {
    816                         ontology = dbnp.data.Ontology.getBioPortalOntology( id );
    817                 } catch( Exception e ) {
     817                        ontology = dbnp.data.Ontology.getBioPortalOntology(id);
     818                } catch (Exception e) {
    818819                        response.status = 500;
    819820                        render 'Ontology with ID ' + id + ' not found';
     
    821822                }
    822823
    823                 if( !ontology ) {
     824                if (!ontology) {
    824825                        response.status = 404;
    825826                        render 'Ontology with ID ' + id + ' not found';
     
    830831                if (!ontology.validate()) {
    831832                        response.status = 500;
    832                         render ontology.errors.join( '; ' );
     833                        render ontology.errors.join('; ');
    833834                        return;
    834835                }
     
    842843         * Adds a ontolgy based on the term ID given
    843844         *
    844          * @param       ncboID
    845          * @return      JSON    Ontology object
    846          * @deprecated  User addOntologyById instead, using the ncboId given by the JSON call
     845         * @param ncboID
     846         * @return JSON Ontology object
     847         * @deprecated User addOntologyById instead, using the ncboId given by the JSON call
    847848         */
    848849        def addOntologyByTerm = {
    849850                def id = params.termID;
    850851
    851                 if( !id ) {
     852                if (!id) {
    852853                        response.status = 500;
    853854                        render 'No ID given'
     
    858859
    859860                try {
    860                         ontology = dbnp.data.Ontology.getBioPortalOntologyByTerm( id );
    861                 } catch( Exception e ) {
    862                         response.status = 500;
    863 
    864                         if( e.getMessage() )
    865                                 render e.getMessage()
     861                        ontology = dbnp.data.Ontology.getBioPortalOntologyByTerm(id);
     862                } catch (Exception e) {
     863                        response.status = 500;
     864
     865                        if (e.getMessage())
     866                        render e.getMessage()
    866867                        else
    867868                                render "Unknown error: " + e.getClass()
     
    869870                }
    870871
    871                 if( !ontology ) {
     872                if (!ontology) {
    872873                        response.status = 404;
    873874                        render 'Ontology form term ' + id + ' not found';
     
    878879                if (!ontology.validate()) {
    879880                        response.status = 500;
    880                         render ontology.errors.join( '; ' );
     881                        render ontology.errors.join('; ');
    881882                        return;
    882883                }
     
    887888        }
    888889
    889     /**
    890      * Checks whether a correct entity is given
    891          *
    892          * @return      boolean True if a correct entity is given. Returns false and raises an error otherwise
    893      */
    894     def _checkEntity = {
    895         // got a entity get parameter?
    896         entityName = _parseEntityType();
    897 
    898         if( !entityName ) {
    899             error();
    900             return false;
    901         }
    902 
    903         // Create an object of this type
    904         entity = _getEntity( entityName );
    905 
    906         if( !entity ) {
    907             error();
    908             return false
    909         }
    910 
    911         return true;
    912     }
    913 
    914 
    915     /**
    916      * Checks whether the entity type is given and can be parsed
    917          *
    918          * @return      Name of the entity if parsing is succesful, false otherwise
    919      */
    920     def _parseEntityType() {
    921         def entityName;
    922         if (params.entity) {
    923             // decode entity get parameter
    924             if (grailsApplication.config.crypto) {
    925                     // generate a Blowfish encrypted and Base64 encoded string.
    926                     entityName = Blowfish.decryptBase64(
    927                         params.entity,
    928                         grailsApplication.config.crypto.shared.secret
    929                                         )
    930             } else {
    931                     // base64 only; this is INSECURE! Even though it is not
    932                     // very likely, it is possible to exploit this and have
    933                     // Grails dynamically instantiate whatever class you like.
    934                     // If that constructor does something harmfull this could
    935                     // be dangerous. Hence, use encryption (above) instead...
    936                     entityName = new String(params.entity.toString().decodeBase64())
    937             }
    938 
    939             return entityName;
    940         } else {
    941             return false;
    942         }
    943     }
    944 
    945     /**
    946      * Creates an object of the given entity.
    947          *
     890        /**
     891         * Checks whether a correct entity is given
     892         *
     893         * @return boolean      True if a correct entity is given. Returns false and raises an error otherwise
     894         */
     895        def _checkEntity = {
     896                // got a entity get parameter?
     897                entityName = _parseEntityType();
     898
     899                if (!entityName) {
     900                        error();
     901                        return false;
     902                }
     903
     904                // Create an object of this type
     905                entity = _getEntity(entityName);
     906
     907                if (!entity) {
     908                        error();
     909                        return false
     910                }
     911
     912                return true;
     913        }
     914
     915        /**
     916         * Checks whether the entity type is given and can be parsed
     917         *
     918         * @return Name of the entity if parsing is succesful, false otherwise
     919         */
     920        def _parseEntityType() {
     921                def entityName;
     922                if (params.entity) {
     923                        // decode entity get parameter
     924                        if (grailsApplication.config.crypto) {
     925                                // generate a Blowfish encrypted and Base64 encoded string.
     926                                entityName = Blowfish.decryptBase64(
     927                                        params.entity,
     928                                        grailsApplication.config.crypto.shared.secret
     929                                )
     930                        } else {
     931                                // base64 only; this is INSECURE! Even though it is not
     932                                // very likely, it is possible to exploit this and have
     933                                // Grails dynamically instantiate whatever class you like.
     934                                // If that constructor does something harmfull this could
     935                                // be dangerous. Hence, use encryption (above) instead...
     936                                entityName = new String(params.entity.toString().decodeBase64())
     937                        }
     938
     939                        return entityName;
     940                } else {
     941                        return false;
     942                }
     943        }
     944
     945        /**
     946         * Creates an object of the given entity.
     947         *
    948948         * @return False if the entity is not a subclass of TemplateEntity
    949     */
    950     def _getEntity( entityName ) {
    951         // Find the templates
    952         def entity = Class.forName(entityName, true, this.getClass().getClassLoader())
    953 
    954         // succes, is entity an instance of TemplateEntity?
    955         if (entity.superclass =~ /TemplateEntity$/ || entity.superclass.superclass =~ /TemplateEntity$/) {
    956             return entity;
    957         } else {
    958             return false;
    959         }
    960 
    961     }
     949        */
     950        def _getEntity(entityName) {
     951                // Find the templates
     952                def entity = Class.forName(entityName, true, this.getClass().getClassLoader())
     953
     954                // succes, is entity an instance of TemplateEntity?
     955                if (entity.superclass =~ /TemplateEntity$/ || entity.superclass.superclass =~ /TemplateEntity$/) {
     956                        return entity;
     957                } else {
     958                        return false;
     959                }
     960
     961        }
    962962
    963963        def templateEntityList = {
    964964                def entities = [
    965                         [ name: 'Study', entity: 'dbnp.studycapturing.Study' ],
    966                         [ name: 'Subject', entity: 'dbnp.studycapturing.Subject' ],
    967                         [ name: 'Event', entity: 'dbnp.studycapturing.Event' ],
    968                         [ name: 'Sampling Event', entity: 'dbnp.studycapturing.SamplingEvent' ],
    969                         [ name: 'Sample', entity: 'dbnp.studycapturing.Sample' ],
    970                         [ name: 'Assay', entity: 'dbnp.studycapturing.Assay' ]
     965                        [name: 'Study', entity: 'dbnp.studycapturing.Study'],
     966                        [name: 'Subject', entity: 'dbnp.studycapturing.Subject'],
     967                        [name: 'Event', entity: 'dbnp.studycapturing.Event'],
     968                        [name: 'Sampling Event', entity: 'dbnp.studycapturing.SamplingEvent'],
     969                        [name: 'Sample', entity: 'dbnp.studycapturing.Sample'],
     970                        [name: 'Assay', entity: 'dbnp.studycapturing.Assay']
    971971                ]
    972972
    973                 entities.each { 
     973                entities.each {
    974974                        // add the entity class name to the element
    975975                        // do we have crypto information available?
Note: See TracChangeset for help on using the changeset viewer.