Ignore:
Timestamp:
Nov 19, 2010, 11:51:09 AM (10 years ago)
Author:
robert@…
Message:

The templateeditor is now capable of adding new items to a stringlist (that is in use), or adding new ontologies to a ontologyterm field that is in use. See ticket #74

Location:
trunk/grails-app/domain/dbnp/studycapturing
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r1167 r1175  
    600600                        // iterate through ontologies and find term
    601601                        field.ontologies.each() { ontology ->
    602                                 def term = ontology.giveTermByName(value)
    603 
    604                                 // found a term?
    605                                 if (term) {
    606                                         value = term
    607                                 }
     602                                // If we've found a term already, value.class == Term. In that case,
     603                                // we shouldn't look further. Unfortunately, groovy doesn't support breaking out of
     604                                // each(), so we check it on every iteration.
     605                                if( value.class == String ) {
     606                                        def term = ontology.giveTermByName(value)
     607
     608                                        // found a term?
     609                                        if (term) {
     610                                                value = term
     611                                        }
     612                                }
     613                        }
     614
     615                        // If the term is not found in any ontology
     616                        if( value.class == String ) {
    608617                                // TODO: search ontology for the term online (it may still exist) and insert it into the Term cache
    609618                                // if not found, throw exception
    610                                 else {
    611                                         throw new IllegalArgumentException("Ontology term not recognized (not in the GSCF ontology cache): ${value} when setting field ${fieldName}")
    612                                 }
     619                                throw new IllegalArgumentException("Ontology term not recognized (not in the GSCF ontology cache): ${value} when setting field ${fieldName}")
    613620                        }
    614621                }
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateField.groovy

    r1160 r1175  
    7676                entity column:"templatefieldentity"
    7777                unit column:"templatefieldunit"
    78                 comment column:"templatefieldcomment"               
     78                comment column:"templatefieldcomment"
    7979        }
    8080
     
    109109
    110110        /**
     111         * Retrieves all list items of a stringlist template field that have been used in an object
     112         *
     113         * @return      ArrayList containing all list items of this template field that have been used in an object.
     114         */
     115        def getUsedListEntries() {
     116                if( this.type != TemplateFieldType.STRINGLIST )
     117                        return []
     118
     119                return this.listEntries.findAll { this.entryUsed( it ) }
     120        }
     121
     122        /**
     123         * Retrieves all list items of a stringlist template field that have never been used in an object
     124         *
     125         * @return      ArrayList containing all list items of this template field that have nevert been used in an object.
     126         */
     127        def getNonUsedListEntries() {
     128                if( this.type != TemplateFieldType.STRINGLIST )
     129                        return []
     130               
     131                return this.listEntries.findAll { !this.entryUsed( it ) }
     132        }
     133
     134        /**
     135         * Retrieves all ontologies of an ontologyterm template field that have been used in an object
     136         *
     137         * @return      ArrayList containing all ontologies of this template field that have been used in an object
     138         *                      (i.e. all ontologies from which a term has been selected in this template field).
     139         */
     140        def getUsedOntologies() {
     141                if( this.type != TemplateFieldType.ONTOLOGYTERM )
     142                        return []
     143
     144                return this.ontologies.findAll { this.entryUsed( it ) }
     145        }
     146
     147        /**
     148         * Retrieves all list items of an ontologyterm template field that have never been used in an object
     149         *
     150         * @return      ArrayList containing all ontologies of this template field that have never been used in an object.
     151         *                      (i.e. all ontologies from which no term has been selected in this template field).
     152         */
     153        def getNonUsedOntologies() {
     154                if( this.type != TemplateFieldType.ONTOLOGYTERM )
     155                        return []
     156
     157                return this.ontologies.findAll { !this.entryUsed( it ) }
     158        }
     159
     160        /**
    111161         * Checks whether this template field is used in a template
    112162         *
     
    151201         */
    152202        def isFilled() {
    153                 // Find all entities that use this template
     203                // Find all templates that use this template field
    154204                def templates = getUses();
    155205
     
    157207                        return false;
    158208
     209                // Find all entities that use these templates
    159210                def c = this.entity.createCriteria()
    160211                def entities = c {
     
    186237
    187238                return filledEntities.size() > 0;
     239        }
     240
     241        /**
     242         * Checks whether this template field is filled in all objects using a template with this template field
     243         * If the template field is never used, the method returns true. If the template field is used in a template,
     244         * but no objects with this template exist, the method also returns true
     245         *
     246         * @returns             false iff objects exist using this template field, but without a value for this field. true otherwise
     247         */
     248        def isFilledInAllObjects() {
     249                // Find all templates that use this entity
     250                def templates = getUses();
     251
     252                if( templates.size() == 0 )
     253                        return true;
     254
     255                // Find all entities that use these templates
     256                def c = this.entity.createCriteria()
     257                def entities = c {
     258                        'in'("template",templates)
     259                }
     260
     261                if( entities.size() == 0 )
     262                        return true;
     263
     264                def emptyEntities = entities.findAll { entity -> !entity.getFieldValue( this.name ) }
     265
     266                return ( emptyEntities.size() == 0 );
    188267        }
    189268
     
    211290         */
    212291        def entryUsed(TemplateFieldListItem item) {
    213                 //return numUses() > 0;
     292                if( this.type != TemplateFieldType.STRINGLIST )
     293                        return false;
     294
     295                // Find all templates that use this template field
     296                def templates = getUses();
     297
     298                if( templates.size() == 0 )
     299                        return false;
     300
     301                // Find all entities that use these templates
     302                def c = this.entity.createCriteria()
     303                def entities = c {
     304                        'in'("template",templates)
     305                }
     306
     307                if( entities.size() == 0 )
     308                        return false
     309                       
     310                def entitiesWithListItem = entities.findAll { entity -> entity.getFieldValue( this.name ).equals( item ) }
     311
     312                return entitiesWithListItem.size() > 0;
    214313        }
    215314
     
    220319         * @returns                     true iff the ontology is part of this template field and a term from the given
    221320         *                                      ontology is selected in an entity where this template field is used. false otherwise
    222          *                                      Returns false if the type of this template field is other than ONTOLOGY
     321         *                                      Returns false if the type of this template field is other than ONTOLOGYTERM
    223322         */
    224323        def entryUsed(Ontology item) {
    225                 //return numUses() > 0;
     324                if( this.type != TemplateFieldType.ONTOLOGYTERM )
     325                        return false;
     326
     327                // Find all templates that use this template field
     328                def templates = getUses();
     329
     330                // If the template field is never used in a template, it will also never
     331                // be filled, and this Ontology will never be used
     332                if( templates.size() == 0 )
     333                        return false;
     334
     335                // Find all entities that use these templates
     336                def c = this.entity.createCriteria()
     337                def entities = c {
     338                        'in'("template",templates)
     339                }
     340
     341                if( entities.size() == 0 )
     342                        return false
     343
     344                def entitiesWithOntology = entities.findAll { entity ->
     345                        def value = entity.getFieldValue( this.name );
     346                        if( value )
     347                                return value.ontology.equals( item )
     348                        else
     349                                return false;
     350                }
     351
     352                return entitiesWithOntology.size() > 0;
    226353        }
    227354
Note: See TracChangeset for help on using the changeset viewer.