Changeset 1426 for trunk


Ignore:
Timestamp:
Jan 21, 2011, 7:37:02 PM (9 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
Location:
trunk
Files:
14 deleted
39 edited

Legend:

Unmodified
Added
Removed
  • trunk/application.properties

    r1423 r1426  
    11#Grails Metadata file
    2 #Fri Jan 21 13:29:24 CET 2011
     2#Fri Jan 21 19:09:57 CET 2011
    33app.build.display.info=0
    44app.build.svn.revision=1079
     
    1313plugins.db-util=0.4
    1414plugins.famfamfam=1.0.1
     15plugins.gdt=0.0.1
    1516plugins.grom=0.2.2
    1617plugins.hibernate=1.3.6
  • trunk/grails-app/conf/BootStrap.groovy

    r1384 r1426  
    22import dbnp.authentication.SecUser
    33import org.codehaus.groovy.grails.commons.GrailsApplication
    4 import dbnp.data.Ontology
    5 import dbnp.studycapturing.Template
     4import nl.grails.plugins.gdt.*
    65import dbnp.studycapturing.Study
    7 import dbnp.studycapturing.TemplateEntity
    86import dbnp.studycapturing.Subject
    97import dbnp.studycapturing.Sample
  • trunk/grails-app/conf/BootStrapStudies.groovy

    r1386 r1426  
    1010
    1111import dbnp.studycapturing.*
    12 import dbnp.data.Term
    13 import dbnp.data.Ontology
     12import nl.grails.plugins.gdt.*
    1413import org.codehaus.groovy.grails.commons.GrailsApplication
    1514import grails.util.GrailsUtil
  • trunk/grails-app/conf/BootStrapTemplates.groovy

    r1399 r1426  
    1010
    1111import dbnp.studycapturing.*
    12 import dbnp.data.Ontology
     12import nl.grails.plugins.gdt.*
    1313import org.codehaus.groovy.grails.commons.GrailsApplication
    1414
  • trunk/grails-app/conf/BuildConfig.groovy

    r1319 r1426  
    4646//grails.plugin.location.'grom' = '../grom'
    4747//grails.plugin.location.'ajaxflow' = '../ajaxflow'
     48//grails.plugin.location.'gdt' = '../gdt'
    4849//grails.plugin.location.'jumpbar' = '../jumpbar'
  • trunk/grails-app/controllers/HomeController.groovy

    r1397 r1426  
    1 import dbnp.studycapturing.Study
    2 import dbnp.studycapturing.Template
     1import dbnp.studycapturing.*
    32import org.codehaus.groovy.grails.commons.GrailsApplication
    43
  • trunk/grails-app/controllers/dbnp/exporter/ExporterController.groovy

    r1222 r1426  
    210210        println "----- SUBJECT -----"
    211211        for (u in 0..sample.parentSubject.giveFields().unique().size()-1){
    212             TemplateField tf = sample.parentSubject.giveFields().getAt(u)
     212            nl.grails.plugins.gdt.TemplateField tf = sample.parentSubject.giveFields().getAt(u)
    213213            println tf.name
    214214            row.createCell((short)9+u).setCellValue(tf.name)
     
    221221        println "----- SAMPLING EVENT -----"
    222222        for (t in 0..sample.parentEvent.giveFields().unique().size()-1){
    223             TemplateField tf =sample.parentEvent.giveFields().getAt(t)
     223            nl.grails.plugins.gdt.TemplateField tf =sample.parentEvent.giveFields().getAt(t)
    224224            println tf.name
    225225            row.createCell((short)9+sample.parentSubject.giveFields().unique().size()+t).setCellValue("samplingEvent-"+tf.name)
     
    237237        println "----- SAMPLE -----"
    238238        for (v in 0..sample.giveFields().unique().size()-1){
    239             TemplateField tf =sample.giveFields().getAt(v)
     239            nl.grails.plugins.gdt.TemplateField tf =sample.giveFields().getAt(v)
    240240            println tf.name
    241241            row.createCell((short)9+sample.parentSubject.giveFields().unique().size()+v+sample.parentEvent.giveFields().unique().size()).setCellValue("sample-"+tf.name)
  • trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy

    r1422 r1426  
    11package dbnp.importer
    22
    3 import dbnp.studycapturing.Study
    4 import dbnp.studycapturing.Subject
    5 import dbnp.studycapturing.Sample
    6 import dbnp.studycapturing.Event
    7 import dbnp.studycapturing.Template
    8 
     3import dbnp.studycapturing.*
     4import nl.grails.plugins.gdt.*
    95import org.apache.poi.ss.usermodel.Workbook
    10 
    116import grails.converters.JSON
    127import cr.co.arquetipos.crypto.Blowfish
    13 
    148import org.codehaus.groovy.grails.plugins.web.taglib.ValidationTagLib
    15 
    169import grails.plugins.springsecurity.Secured
    17 
    1810import org.hibernate.SessionFactory
    1911
     
    446438                                entity.giveFields().each { field ->
    447439                                        // field of type ontology and value "#invalidterm"?
    448                                         if (field.type == dbnp.studycapturing.TemplateFieldType.ONTOLOGYTERM &&
     440                                        if (field.type == nl.grails.plugins.gdt.TemplateFieldType.ONTOLOGYTERM &&
    449441                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] == "#invalidterm"
    450442                                        ) {
    451443                                                invalidontologies++
    452444                                        } else
    453                                         if (field.type == dbnp.studycapturing.TemplateFieldType.ONTOLOGYTERM &&
     445                                        if (field.type == nl.grails.plugins.gdt.TemplateFieldType.ONTOLOGYTERM &&
    454446                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] != "#invalidterm") {
    455447                                                removeFailedCell(flow.importer_failedcells, entity)
  • trunk/grails-app/controllers/dbnp/studycapturing/AssayModuleController.groovy

    r959 r1426  
    1515package dbnp.studycapturing
    1616
     17import nl.grails.plugins.gdt.*
     18
    1719class AssayModuleController {
    18 
    1920        // Scaffold this class to circumvent not being able to add assays (0.4)
    20         def scaffold = dbnp.studycapturing.AssayModule
     21        def scaffold = nl.grails.plugins.gdt.AssayModule
    2122}
  • trunk/grails-app/controllers/dbnp/studycapturing/StudyController.groovy

    r1261 r1426  
    313313                                if( value ) {
    314314                                        if( templateField.type == TemplateFieldType.RELTIME )
    315                                                 value = new RelTime( value ).toString();
     315                                                value = new nl.grails.plugins.gdt.RelTime( value ).toString();
    316316
    317317                        def param = templateField.name + " = " + value;
  • trunk/grails-app/controllers/dbnp/studycapturing/StudyWizardController.groovy

    r1392 r1426  
    77import dbnp.authentication.SecUser
    88import org.codehaus.groovy.grails.plugins.web.taglib.ValidationTagLib
     9import nl.grails.plugins.gdt.*
    910
    1011/**
     
    15521553                                                                def samplingEventName = ucwords(event.template.name)
    15531554                                                                def eventGroupName = ucwords(eventGroup.name).replaceAll("([ ]{1,})", "")
    1554                                                                 def sampleName = (ucwords(subject.name) + '_' + samplingEventName + '_' + eventGroupName + '_' + new RelTime(event.startTime).toString()).replaceAll("([ ]{1,})", "")
     1555                                                                def sampleName = (ucwords(subject.name) + '_' + samplingEventName + '_' + eventGroupName + '_' + new nl.grails.plugins.gdt.RelTime(event.startTime).toString()).replaceAll("([ ]{1,})", "")
    15551556                                                                def tempSampleIterator = 0
    15561557                                                                def tempSampleName = sampleName
     
    16481649                                                        def samplingEventName = ucwords(samplingEvent.template.name)
    16491650                                                        def eventGroupName = ucwords(eventGroup.name)
    1650                                                         def sampleName = (ucwords(subject.name) + '_' + samplingEventName + '_' + eventGroupName + '_' + new RelTime(samplingEvent.startTime).toString()).replaceAll("([ ]{1,})", "")
     1651                                                        def sampleName = (ucwords(subject.name) + '_' + samplingEventName + '_' + eventGroupName + '_' + new nl.grails.plugins.gdt.RelTime(samplingEvent.startTime).toString()).replaceAll("([ ]{1,})", "")
    16511652                                                        def tempSampleIterator = 0
    16521653                                                        def tempSampleName = sampleName
  • 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?
  • trunk/grails-app/controllers/dbnp/studycapturing/TermEditorController.groovy

    r1192 r1426  
    1515package dbnp.studycapturing
    1616
    17 import dbnp.data.Term
    18 import dbnp.data.Ontology
     17import nl.grails.plugins.gdt.*
    1918
    2019class TermEditorController {
  • trunk/grails-app/domain/dbnp/authentication/SecUser.groovy

    r1213 r1426  
    55        String username
    66        String password
    7         String email
     7        String email
    88        Date dateCreated
    99        boolean enabled
     
    1111        boolean accountLocked
    1212        boolean passwordExpired
    13         boolean userConfirmed   // True if the user has confirmed his subscription using the link in the email
    14         boolean adminConfirmed  // True if the administrator has confirmed this subscription using the link in the email
     13        boolean userConfirmed   // True if the user has confirmed his subscription using the link in the email
     14        boolean adminConfirmed  // True if the administrator has confirmed this subscription using the link in the email
    1515
    1616        static constraints = {
    1717                username blank: false, unique: true
    1818                password blank: false
    19                 email blank: false
     19                email blank: false
    2020        }
    2121
    2222        static mapping = {
    2323                password column: '`password`'
    24                 enabled formula: 'USER_CONFIRMED AND ADMIN_CONFIRMED'
     24                enabled formula: 'USER_CONFIRMED AND ADMIN_CONFIRMED'
    2525        }
    2626
     
    2929        }
    3030
    31         public boolean equals(Object y)
    32         {
    33                 if( !( y instanceof SecUser ) ) {
     31        public boolean equals(Object y) {
     32                if (!(y instanceof SecUser)) {
    3433                        return false;
    3534                }
     
    4140
    4241        public boolean hasAdminRights() {
    43                 return getAuthorities().contains( SecRole.findByAuthority( 'ROLE_ADMIN' ) );
     42                return getAuthorities().contains(SecRole.findByAuthority('ROLE_ADMIN'));
    4443        }
    4544
  • trunk/grails-app/domain/dbnp/importer/ImportCell.groovy

    r1277 r1426  
    11package dbnp.importer
    2 
    3 import dbnp.studycapturing.Identity
    42
    53/**
     
    1816 */
    1917
    20 class ImportCell extends Identity implements Serializable {
     18class ImportCell extends nl.grails.plugins.gdt.Identity implements Serializable {
    2119    MappingColumn mappingcolumn
    2220    int entityidentifier
  • trunk/grails-app/domain/dbnp/importer/ImportRecord.groovy

    r1277 r1426  
    1414 */
    1515package dbnp.importer
    16 import dbnp.studycapturing.Identity
    1716
    18 class ImportRecord extends Identity implements Serializable {
     17class ImportRecord extends nl.grails.plugins.gdt.Identity implements Serializable {
    1918    static hasMany = [ importcells: ImportCell ]
    2019   
  • trunk/grails-app/domain/dbnp/importer/MappingColumn.groovy

    r1277 r1426  
    11package dbnp.importer
    2 import dbnp.studycapturing.TemplateField
    3 import dbnp.studycapturing.Identity
     2
     3import nl.grails.plugins.gdt.*
    44
    55/**
     
    1515
    1616        String name
    17         dbnp.studycapturing.TemplateFieldType templatefieldtype
     17        nl.grails.plugins.gdt.TemplateFieldType templatefieldtype
    1818        Class entity
    1919        String property
  • trunk/grails-app/domain/dbnp/studycapturing/Assay.groovy

    r1198 r1426  
    11package dbnp.studycapturing
     2import nl.grails.plugins.gdt.*
    23
    34/**
     
    67 * this data can be found.
    78 */
    8 class Assay extends TemplateEntity {
     9class Assay extends nl.grails.plugins.gdt.TemplateEntity {
    910        // The name of the assay, which should indicate the measurements represented in this assay to the user.
    1011        String name
  • trunk/grails-app/domain/dbnp/studycapturing/Event.groovy

    r1198 r1426  
    11package dbnp.studycapturing
     2
     3import nl.grails.plugins.gdt.*
    24
    35/**
     
    1113 * $Date$
    1214 */
    13 class Event extends TemplateEntity {
     15class Event extends nl.grails.plugins.gdt.TemplateEntity {
    1416
    1517        // uncommented due to searchable issue
  • trunk/grails-app/domain/dbnp/studycapturing/EventGroup.groovy

    r959 r1426  
    99 * $Date$
    1010 */
    11 class EventGroup extends Identity {
     11class EventGroup extends nl.grails.plugins.gdt.Identity {
    1212        String name
    1313
  • trunk/grails-app/domain/dbnp/studycapturing/Person.groovy

    r1154 r1426  
    1111 * $Date$
    1212 */
    13 class Person extends Identity {
     13class Person extends nl.grails.plugins.gdt.Identity {
    1414        String title
    1515        String gender
  • trunk/grails-app/domain/dbnp/studycapturing/PersonAffiliation.groovy

    r959 r1426  
    1010 * $Date$
    1111 */
    12 class PersonAffiliation extends Identity {
     12class PersonAffiliation extends nl.grails.plugins.gdt.Identity {
    1313
    1414        String institute
  • trunk/grails-app/domain/dbnp/studycapturing/PersonRole.groovy

    r959 r1426  
    1111 * $Date$
    1212 */
    13 class PersonRole extends Identity {
     13class PersonRole extends nl.grails.plugins.gdt.Identity {
    1414
    1515        /** The name of the role, such as Project Leader or PI */
  • trunk/grails-app/domain/dbnp/studycapturing/Publication.groovy

    r959 r1426  
    1212 * $Date$
    1313 */
    14 class Publication extends Identity {
     14class Publication extends nl.grails.plugins.gdt.Identity {
    1515        String title
    1616        String pubMedID
  • trunk/grails-app/domain/dbnp/studycapturing/Sample.groovy

    r1373 r1426  
    11package dbnp.studycapturing
    22
    3 import dbnp.data.Term
     3import nl.grails.plugins.gdt.*
    44
    55/**
     
    1111 * $Date$
    1212 */
    13 class Sample extends TemplateEntity {
     13class Sample extends nl.grails.plugins.gdt.TemplateEntity {
    1414        // uncommented due to searchable issue
    1515        // @see http://jira.codehaus.org/browse/GRAILSPLUGINS-1577
  • trunk/grails-app/domain/dbnp/studycapturing/SamplingEvent.groovy

    r1198 r1426  
    11package dbnp.studycapturing
     2import nl.grails.plugins.gdt.*
    23
    34/**
     
    1314 * $Date$
    1415 */
    15 class SamplingEvent extends TemplateEntity {
     16class SamplingEvent extends nl.grails.plugins.gdt.TemplateEntity {
    1617        // A SamplingEvent always belongs to one study.
    1718        // Although this is technically inherited from Event, we have to specify it here again.
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r1357 r1426  
    22
    33import dbnp.authentication.SecUser
     4import nl.grails.plugins.gdt.*
    45
    56/**
     
    1112 * $Date$
    1213 */
    13 class Study extends TemplateEntity {
     14class Study extends nl.grails.plugins.gdt.TemplateEntity {
    1415        static searchable = true
    1516       
  • trunk/grails-app/domain/dbnp/studycapturing/StudyPerson.groovy

    r959 r1426  
    99 * $Date$
    1010 */
    11 class StudyPerson extends Identity {
     11class StudyPerson extends nl.grails.plugins.gdt.Identity {
    1212
    1313        // A StudyPerson relation always belongs to one study.
  • trunk/grails-app/domain/dbnp/studycapturing/Subject.groovy

    r1314 r1426  
    11package dbnp.studycapturing
    22
    3 import dbnp.data.Term
    4 import dbnp.data.Ontology
     3import nl.grails.plugins.gdt.*
    54
    65/**
     
    1211 * $Date$
    1312 */
    14 class Subject extends TemplateEntity {
     13class Subject extends nl.grails.plugins.gdt.TemplateEntity {
    1514        // uncommented due to searchable issue
    1615        // @see http://jira.codehaus.org/browse/GRAILSPLUGINS-1577
  • trunk/grails-app/services/dbnp/importer/ImporterService.groovy

    r1422 r1426  
    2020import org.apache.poi.xssf.usermodel.XSSFCell
    2121
    22 import dbnp.studycapturing.TemplateFieldType
    23 import dbnp.studycapturing.Template
    24 import dbnp.studycapturing.SamplingEvent
    25 import dbnp.studycapturing.Study
    26 import dbnp.studycapturing.Subject
    27 import dbnp.studycapturing.Event
    28 import dbnp.studycapturing.Sample
    29 import dbnp.data.Term
     22import nl.grails.plugins.gdt.*
     23import dbnp.studycapturing.*
    3024import org.apache.commons.lang.RandomStringUtils
    3125
  • trunk/grails-app/services/dbnp/studycapturing/SynchronizationService.groovy

    r1357 r1426  
    1515package dbnp.studycapturing
    1616
     17import nl.grails.plugins.gdt.*
    1718import com.sun.xml.internal.ws.api.streaming.XMLStreamReaderFactory.Default;
    1819
  • trunk/grails-app/taglib/dbnp/importer/ImporterTagLib.groovy

    r1277 r1426  
    44 * The importer tag library gives support for automating several 'components'
    55 *
    6  * @package     importer
    7  * @author      t.w.abma@umcutrecht.nl
    8  * @since       20100202
     6 * @package importer
     7 * @author t.w.abma@umcutrecht.nl
     8 * @since 20100202
    99 *
    1010 * Revision information:
     
    1515
    1616package dbnp.importer
    17 import dbnp.studycapturing.Template
    18 import dbnp.studycapturing.TemplateFieldType
     17
     18import dbnp.studycapturing.*
     19import nl.grails.plugins.gdt.*
    1920import org.apache.poi.ss.usermodel.Cell
    2021import org.apache.poi.ss.usermodel.DataFormatter
    2122
    2223class ImporterTagLib {
    23     static namespace = 'importer'
    24     def ImporterService
    25 
    26     /**
    27     * @param header string array containing header
    28     * @param datamatrix two dimensional array containing actual data
    29     * @return preview of the data with the ability to adjust the datatypes
    30     */
    31     def preview = { attrs ->
    32        
    33         def header = attrs['header']
    34         def datamatrix = attrs['datamatrix']
    35 
    36         out << render (template:"common/preview", model:[header:header, datamatrix:datamatrix])
    37     }
    38 
    39     /**
    40      * @param datamatrix two dimensional array containing entities with read values
    41      * @return postview of the imported data
    42      */
    43     def postview = { attrs ->
    44         def datamatrix = attrs['datamatrix']
    45 
    46         out << render (template:"common/postview", model:[datamatrix:datamatrix])
    47     }
    48 
    49     def entity = { attrs ->
    50         out << entities[attrs['index']].name
    51     }
    52 
    53     def datapreview = { attrs ->
    54         def datamatrix = attrs['datamatrix']
    55         out << render (template:"common/datapreview", model:[datamatrix:datamatrix])
    56     }
    57 
    58     /**
    59      * Show missing properties
    60      */
    61     def missingProperties = { attrs ->
    62         def datamatrix = attrs['datamatrix']
    63         def failedcells = attrs['failedcells']
    64         out << render (template:"common/missingproperties", model:[datamatrix:datamatrix, failedcells:failedcells])
    65     }
    66 
    67     /**
    68      * Show failed cells
    69      */
    70     def failedCells = { attrs ->
    71         def failedcells = attrs['failedcells']
    72         out << render (template:"common/failedcells", model:[failedcells:failedcells])
    73     }
    74 
    75     /**
    76      * @param entities array containing selected entities
    77      * @param header array containing mappingcolumn objects
    78      * @param allfieldtypes if set, show all fields   
    79      */
    80     def properties = { attrs ->
    81         def header = attrs['header']
    82         def entities = attrs['entities']
    83 
    84         out << render ( template:"common/properties_horizontal" )
    85     }
    86 
    87     /**
    88      * Possibly this will later on return an AJAX-like autocompletion chooser for the fields?
    89      *
    90      * @param name name for the property chooser element
    91      * @param importtemplate_id template identifier where fields are retrieved from
    92      * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
    93      * @param MappingColumn object containing all required information
    94      * @param allfieldtypes boolean true if all templatefields should be listed, otherwise only show filtered templatefields
    95      * @return chooser object
    96      * */
    97     def propertyChooser = { attrs ->
    98         // TODO: this should be changed to retrieving fields per entity instead of from one template
    99         //       and session variables should not be used inside the service, migrate to controller
    100    
    101         def t = Template.get(attrs['template_id'])
    102         def mc = attrs['mappingcolumn']
    103         def allfieldtypes = attrs['allfieldtypes']
    104     def matchvalue = attrs['matchvalue']
    105         def domainfields = mc.entity.giveDomainFields().findAll { it.type == mc.templatefieldtype }
    106             domainfields = domainfields.findAll { it.preferredIdentifier != mc.identifier}
    107 
    108         //def templatefields = (allfieldtypes=="true") ? t.fields : t.fields.findAll { it.type == mc.templatefieldtype }
    109         def templatefields = (allfieldtypes=="true") ?
    110             t.fields + mc.entity.giveDomainFields() :
    111             t.fields.findAll { it.type == mc.templatefieldtype } + domainfields
    112 
    113         // map identifier to preferred column
    114         def prefcolumn = mc.entity.giveDomainFields().findAll { it.preferredIdentifier == true }
    115 
    116         (mc.identifier) ? out << createPropertySelect(attrs['name'], prefcolumn, matchvalue, mc.index) :
    117             out << createPropertySelect(attrs['name'], templatefields, matchvalue, mc.index)
    118     }
    119 
    120     /**
    121      * Create the property chooser select element
    122      *
    123      * @param name name of the HTML select object
    124      * @param options list of options (fields) to be used
    125      * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
    126      * @param columnIndex column identifier (corresponding to position in header of the Excel sheet)
    127      * @return HTML select object
    128      */
    129     def createPropertySelect(String name, options, matchvalue, Integer columnIndex)
    130     {
    131         // Determine which field in the options list matches the best with the matchvalue
    132         def mostsimilar = ImporterService.mostSimilar(matchvalue, options)
    133 
    134         def res = "<select style=\"font-size:10px\" name=\"${name}.index.${columnIndex}\">"
    135 
    136         res += "<option value=\"dontimport\">Don't import</option>"
    137 
    138         options.each { f ->
    139             res+= "<option value=\"${f.name}\""
    140 
    141             res+= (mostsimilar.toString().toLowerCase()==f.name.toLowerCase()) ?
    142                     " selected>" :
    143                     ">"
    144            
    145             res+= (f.preferredIdentifier) ?
    146                     "${f.name} (IDENTIFIER)</option>" :
    147                     "${f.name}</option>"
    148         }
    149 
    150         res += "</select>"
    151         return res
    152     }
    153 
    154     /**
    155     * @param selected selected TemplateFieldType
    156     * @param custval custom value to be combined in the option(s) of the selector
    157     * @param name name of the HTML select object
    158     * @return HTML select object
    159     *
    160     * @see dbnp.studycapturing.TemplateFieldType
    161     */
    162 
    163      def entitySelect = { attrs ->
    164         def sel = (attrs['selected']==null) ? -1 : attrs['selected']
    165         def custval = (attrs['customvalue']==null) ? "" : attrs['customvalue']
    166         def name = (attrs['name']==null) ? -1 : attrs['name']
    167 
    168         def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
    169 
    170         grailsApplication.config.gscf.domain.importableEntities.each { e ->
    171             res += "<option value=\"${e.value.name}\""
    172             res += (e.value.type == sel) ? " selected" : ""
    173             res += ">${e.value.name}</option>"
    174         }
    175 
    176         res += "</select>"
    177         out << res
    178     }
    179 
    180     /**
    181      * Create a templatefieldtype selector
    182      *
    183     * @param selected selected TemplateFieldType
    184     * @param customvalue custom value to be combined in the option(s) of the selector
    185     * @param name name of the HTML select object
    186     * @return HTML select object
    187     *
    188     * @see dbnp.studycapturing.TemplateFieldType
    189     */
    190     def templatefieldtypeSelect = { attrs ->
    191         def selected = (attrs['selected']==null) ? -1 : attrs['selected']
    192         def custval = (attrs['customvalue']==null) ? "" : attrs['customvalue']
    193         def name = (attrs['name']==null) ? "" : attrs['name']   
    194 
    195         def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
    196 
    197         TemplateFieldType.list().each { e ->
    198             res += "<option value=\"${e}\""
    199             res += (e == selected) ? " selected" : ""
    200             res += ">${e}</option>"
    201         }
    202 
    203         res += "</select>"
    204 
    205         out << res
    206     }
    207 
    208     /**
    209     * @param cell Cell variable
    210     * @return good representation of variable (instead of toString())
    211     */
    212     def displayCell = { attrs ->       
    213         def cell = attrs['cell']
    214         def df = new DataFormatter()
    215 
    216         switch (cell.getCellType()) {
    217             case Cell.CELL_TYPE_STRING  :   out << cell.getStringCellValue()
    218                                                     break
    219             case Cell.CELL_TYPE_NUMERIC :   out << df.formatCellValue(cell)
    220                                                     break
    221         }
    222     }
     24        static namespace = 'importer'
     25        def ImporterService
     26
     27        /**
     28         * @param header string array containing header
     29         * @param datamatrix two dimensional array containing actual data
     30         * @return preview of the data with the ability to adjust the datatypes
     31         */
     32        def preview = { attrs ->
     33
     34                def header = attrs['header']
     35                def datamatrix = attrs['datamatrix']
     36
     37                out << render(template: "common/preview", model: [header: header, datamatrix: datamatrix])
     38        }
     39
     40        /**
     41         * @param datamatrix two dimensional array containing entities with read values
     42         * @return postview of the imported data
     43         */
     44        def postview = { attrs ->
     45                def datamatrix = attrs['datamatrix']
     46
     47                out << render(template: "common/postview", model: [datamatrix: datamatrix])
     48        }
     49
     50        def entity = { attrs ->
     51                out << entities[attrs['index']].name
     52        }
     53
     54        def datapreview = { attrs ->
     55                def datamatrix = attrs['datamatrix']
     56                out << render(template: "common/datapreview", model: [datamatrix: datamatrix])
     57        }
     58
     59        /**
     60         * Show missing properties
     61         */
     62        def missingProperties = { attrs ->
     63                def datamatrix = attrs['datamatrix']
     64                def failedcells = attrs['failedcells']
     65                out << render(template: "common/missingproperties", model: [datamatrix: datamatrix, failedcells: failedcells])
     66        }
     67
     68        /**
     69         * Show failed cells
     70         */
     71        def failedCells = { attrs ->
     72                def failedcells = attrs['failedcells']
     73                out << render(template: "common/failedcells", model: [failedcells: failedcells])
     74        }
     75
     76        /**
     77         * @param entities array containing selected entities
     78         * @param header array containing mappingcolumn objects
     79         * @param allfieldtypes if set, show all fields
     80         */
     81        def properties = { attrs ->
     82                def header = attrs['header']
     83                def entities = attrs['entities']
     84
     85                out << render(template: "common/properties_horizontal")
     86        }
     87
     88        /**
     89         * Possibly this will later on return an AJAX-like autocompletion chooser for the fields?
     90         *
     91         * @param name name for the property chooser element
     92         * @param importtemplate_id template identifier where fields are retrieved from
     93         * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
     94         * @param MappingColumn object containing all required information
     95         * @param allfieldtypes boolean true if all templatefields should be listed, otherwise only show filtered templatefields
     96         * @return chooser object
     97         * */
     98        def propertyChooser = { attrs ->
     99                // TODO: this should be changed to retrieving fields per entity instead of from one template
     100                //       and session variables should not be used inside the service, migrate to controller
     101
     102                def t = Template.get(attrs['template_id'])
     103                def mc = attrs['mappingcolumn']
     104                def allfieldtypes = attrs['allfieldtypes']
     105                def matchvalue = attrs['matchvalue']
     106                def domainfields = mc.entity.giveDomainFields().findAll { it.type == mc.templatefieldtype }
     107                domainfields = domainfields.findAll { it.preferredIdentifier != mc.identifier}
     108
     109                //def templatefields = (allfieldtypes=="true") ? t.fields : t.fields.findAll { it.type == mc.templatefieldtype }
     110                def templatefields = (allfieldtypes == "true") ?
     111                        t.fields + mc.entity.giveDomainFields() :
     112                        t.fields.findAll { it.type == mc.templatefieldtype } + domainfields
     113
     114                // map identifier to preferred column
     115                def prefcolumn = mc.entity.giveDomainFields().findAll { it.preferredIdentifier == true }
     116
     117                (mc.identifier) ? out << createPropertySelect(attrs['name'], prefcolumn, matchvalue, mc.index) :
     118                        out << createPropertySelect(attrs['name'], templatefields, matchvalue, mc.index)
     119        }
     120
     121        /**
     122         * Create the property chooser select element
     123         *
     124         * @param name name of the HTML select object
     125         * @param options list of options (fields) to be used
     126         * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
     127         * @param columnIndex column identifier (corresponding to position in header of the Excel sheet)
     128         * @return HTML select object
     129         */
     130        def createPropertySelect(String name, options, matchvalue, Integer columnIndex) {
     131                // Determine which field in the options list matches the best with the matchvalue
     132                def mostsimilar = ImporterService.mostSimilar(matchvalue, options)
     133
     134                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${columnIndex}\">"
     135
     136                res += "<option value=\"dontimport\">Don't import</option>"
     137
     138                options.each { f ->
     139                        res += "<option value=\"${f.name}\""
     140
     141                        res += (mostsimilar.toString().toLowerCase() == f.name.toLowerCase()) ?
     142                                " selected>" :
     143                                ">"
     144
     145                        res += (f.preferredIdentifier) ?
     146                                "${f.name} (IDENTIFIER)</option>" :
     147                                "${f.name}</option>"
     148                }
     149
     150                res += "</select>"
     151                return res
     152        }
     153
     154        /**
     155         * @param selected selected TemplateFieldType
     156         * @param custval custom value to be combined in the option(s) of the selector
     157         * @param name name of the HTML select object
     158         * @return HTML select object
     159         *
     160         * @see nl.grails.plugins.gdt.TemplateFieldType
     161         */
     162
     163        def entitySelect = { attrs ->
     164                def sel = (attrs['selected'] == null) ? -1 : attrs['selected']
     165                def custval = (attrs['customvalue'] == null) ? "" : attrs['customvalue']
     166                def name = (attrs['name'] == null) ? -1 : attrs['name']
     167
     168                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
     169
     170                grailsApplication.config.gscf.domain.importableEntities.each { e ->
     171                        res += "<option value=\"${e.value.name}\""
     172                        res += (e.value.type == sel) ? " selected" : ""
     173                        res += ">${e.value.name}</option>"
     174                }
     175
     176                res += "</select>"
     177                out << res
     178        }
     179
     180        /**
     181         * Create a templatefieldtype selector
     182         *
     183         * @param selected selected TemplateFieldType
     184         * @param customvalue custom value to be combined in the option(s) of the selector
     185         * @param name name of the HTML select object
     186         * @return HTML select object
     187         *
     188         * @see nl.grails.plugins.gdt.TemplateFieldType
     189         */
     190        def templatefieldtypeSelect = { attrs ->
     191                def selected = (attrs['selected'] == null) ? -1 : attrs['selected']
     192                def custval = (attrs['customvalue'] == null) ? "" : attrs['customvalue']
     193                def name = (attrs['name'] == null) ? "" : attrs['name']
     194
     195                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
     196
     197                TemplateFieldType.list().each { e ->
     198                        res += "<option value=\"${e}\""
     199                        res += (e == selected) ? " selected" : ""
     200                        res += ">${e}</option>"
     201                }
     202
     203                res += "</select>"
     204
     205                out << res
     206        }
     207
     208        /**
     209         * @param cell Cell variable
     210         * @return good representation of variable (instead of toString())
     211         */
     212        def displayCell = { attrs ->
     213                def cell = attrs['cell']
     214                def df = new DataFormatter()
     215
     216                switch (cell.getCellType()) {
     217                        case Cell.CELL_TYPE_STRING: out << cell.getStringCellValue()
     218                                break
     219                        case Cell.CELL_TYPE_NUMERIC: out << df.formatCellValue(cell)
     220                                break
     221                }
     222        }
    223223}
  • trunk/grails-app/taglib/dbnp/studycapturing/WizardTagLib.groovy

    r1356 r1426  
    22
    33import dbnp.studycapturing.*
     4import nl.grails.plugins.gdt.*
    45import dbnp.authentication.SecUser
    5 import dbnp.data.*
    66import cr.co.arquetipos.crypto.Blowfish
    77import nl.grails.plugins.ajaxflow.AjaxflowTagLib
  • trunk/grails-app/views/study/show.gsp

    r1286 r1426  
    1 <%@ page import="dbnp.studycapturing.Study" %>
    2 <%@ page import="dbnp.studycapturing.EventGroup" %>
    3 <%@ page import="dbnp.studycapturing.RelTime" %>
     1<%@ page import="dbnp.studycapturing.*" %>
     2<%@ page import="nl.grails.plugins.gdt.*" %>
    43<html>
    54<head>
  • trunk/grails-app/views/study/show_events_table.gsp

    r1213 r1426  
    1 <%@ page import="dbnp.studycapturing.EventGroup" %>
    2 <%@ page import="dbnp.studycapturing.RelTime" %>
     1<%@ page import="dbnp.studycapturing.*" %>
     2<%@ page import="nl.grails.plugins.gdt.*" %>
    33<g:if test="${studyList*.eventGroups?.flatten()?.size()==0}">
    44  No event groups in this study
  • trunk/src/groovy/dbnp/query/Criterion.groovy

    r1424 r1426  
    55import java.text.SimpleDateFormat;
    66
    7 import dbnp.studycapturing.RelTime;
    8 import dbnp.studycapturing.TemplateEntity;
     7import nl.grails.plugins.gdt.*
    98
    109/**
  • trunk/src/groovy/dbnp/query/SampleSearch.groovy

    r1424 r1426  
    1515package dbnp.query
    1616
    17 import java.util.List;
    18 import dbnp.studycapturing.*;
     17import java.util.List
     18import dbnp.studycapturing.*
     19import nl.grails.plugins.gdt.*
    1920
    2021class SampleSearch extends Search {
  • trunk/src/groovy/dbnp/query/Search.groovy

    r1424 r1426  
    1616package dbnp.query
    1717
    18 import dbnp.studycapturing.RelTime
    19 import dbnp.studycapturing.TemplateEntity
    20 import dbnp.studycapturing.TemplateFieldType
     18import nl.grails.plugins.gdt.*
    2119import java.util.List;
    2220import java.text.DateFormat;
  • trunk/src/groovy/dbnp/query/StudySearch.groovy

    r1424 r1426  
    1515package dbnp.query
    1616
    17 import dbnp.studycapturing.*;
     17import dbnp.studycapturing.*
     18import nl.grails.plugins.gdt.*
    1819
    1920class StudySearch extends Search {
Note: See TracChangeset for help on using the changeset viewer.