Changeset 1257 for trunk/grails-app/domain

Timestamp:

Dec 9, 2010, 9:12:10 PM (12 years ago)

Author:

robert@…

Message:

Added an export and import functionality for templates, as described in ticket #76

Location:

trunk/grails-app/domain/dbnp/studycapturing

Files:

• Template.groovy (modified) (2 diffs)
• TemplateEntity.groovy (modified) (1 diff)
• TemplateField.groovy (modified) (1 diff)

trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

@@ -123 +123 @@
 
         /**
+         * Check whether the contents of the other template and the current template are equal.
+         * For this check the name, description and owner don't matter. Also, the order of
+         * template fields doesn't matter
+         *
+         * @return      true iff this template and the other template are used for the same entity and
+         *                      the template contain the same template fields
+         */
+        public boolean contentEquals( Template otherTemplate ) {
+                if( otherTemplate == this )
+                        return true
+
+                if( otherTemplate == null )
+                        return false
+
+                if( otherTemplate.entity != this.entity )
+                        return false
+
+                // Check all template fields
+                if( otherTemplate.fields?.size() != this.fields?.size() )
+                        return false
+
+                if( otherTemplate.fields != null && this.fields != null ) {
+                        for( def field in this.fields ) {
+                                def fieldFound = false;
+                                for( def otherField in otherTemplate.fields ) {
+                                        if( otherField.contentEquals( field ) ) {
+                                                fieldFound = true;
+                                                break
+                                        }
+                                }
+
+                                if( !fieldFound ) {
+                                        return false
+                                }
+                        }
+                }
+
+                // If all tests pass, the objects are content-equal
+                return true
+        }
+
+        /**
          * Look up the type of a certain template subject field
          * @param String fieldName The name of the template field
@@ -210 +252 @@
                 return results
         }
+
+        /**
+         * Create a new template based on the parsed XML object. 
+         *
+         * @see grails.converters.XML#parse(java.lang.String)
+         * @throws IllegalArgumentException
+         * @throws ClassNotFoundException
+         *
+         */
+        public static parse(Object xmlObject, SecUser loggedInUser) {
+                def t = new Template();
+                t.name = xmlObject?.name?.text()
+                t.description = xmlObject?.description?.text()
+
+                // Check whether a correct entity is given. The parseEntity method might
+                // throw a ClassNotFoundException, but that is OK, it should be thrown if the class
+                // doesn't exist.
+                def entity = TemplateEntity.parseEntity( xmlObject.entity?.text() );
+                if( !entity ) {
+                        throw new Exception( "Incorrect entity given" );
+                }
+
+                t.entity = entity
+
+                // Set the owner to the currently logged in user
+                t.owner = loggedInUser
+
+                // Set all template fields
+                xmlObject.templateFields.templateField.each {
+                        def field = TemplateField.parse( it, entity );
+
+                        // Check whether a similar field already exists. For that, we search in all
+                        // template fields with the same name, in order to have as little comparisons
+                        // as possible
+                        for( def otherField in TemplateField.findAllByName( field.name ) ) {
+                                if( field.contentEquals( otherField ) ) {
+                                        field = otherField;
+                                        break;
+                                }
+                        }
+                        
+                        t.addToFields( field );
+                }
+
+                return t
+        }
 }

trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

@@ -781 +781 @@
                 }
         }
+
+    /**
+     * Returns a Class object given by the entityname, but only if it is a subclass of TemplateEntity
+         *
+         * @return A class object of the given entity, null if the entity is not a subclass of TemplateEntity
+         * @throws ClassNotFoundException
+     */
+    static Class parseEntity( String entityName ) {
+                if( entityName == null )
+                        return null
+
+        // Find the templates
+        def entity = Class.forName(entityName, true, Thread.currentThread().getContextClassLoader())
+
+        // succes, is entity an instance of TemplateEntity?
+        if (entity?.superclass =~ /TemplateEntity$/ || entity?.superclass?.superclass =~ /TemplateEntity$/) {
+            return entity;
+        } else {
+            return null;
+        }
+
+    }
 }

trunk/grails-app/domain/dbnp/studycapturing/TemplateField.groovy

@@ -366 +366 @@
         }
 
+
+        /**
+         * Check whether the contents of the other templatefield and the current templatefield are equal.
+         * For this check the comments field doesn't matter. 
+         *
+         * @return      true iff this template field equals the other template field
+         *                      (the comments field may be different)
+         */
+        public boolean contentEquals( Object otherObject ) {
+                if( !( otherObject instanceof TemplateField ) )
+                        return false
+
+                TemplateField otherField = (TemplateField) otherObject;
+
+                if( otherField == this )
+                        return true
+
+                if( otherField == null )
+                        return false
+
+                if( otherField.entity != this.entity ) {
+                        return false
+                }
+                if( otherField.name != this.name ) {
+                        return false
+                }
+                if( otherField.type != this.type ) {
+                        return false
+                }
+                if( otherField.unit != this.unit ) {
+                        return false
+                }
+                if( otherField.required != this.required ) {
+                        return false
+                }
+
+                if( otherField.preferredIdentifier != this.preferredIdentifier ) {
+                        return false
+                }
+
+                // Check whether the list entries are equal (except for the order)
+                def size1 = otherField.listEntries?.size() ?: 0
+                def size2 = this.listEntries?.size() ?: 0
+                if( size1 != size2 ) {
+                        return false
+                }
+                
+                if( otherField.listEntries != null && this.listEntries != null ) {
+                        for( def entry in this.listEntries ) {
+                                def entryFound = false;
+                                for( def otherEntry in otherField.listEntries ) {
+                                        if( otherEntry.name == entry.name ) {
+                                                entryFound = true;
+                                                break
+                                        }
+                                }
+
+                                if( !entryFound ) {
+                                        return false
+                                }
+                        }
+                }
+                
+                // Check whether the ontologies are equal (except for the order)
+                size1 = otherField.ontologies?.size() ?: 0
+                size2 = this.ontologies?.size() ?: 0
+                if( size1 != size2 ) {
+                        return false
+                }
+                if( this.ontologies != null && otherField.ontologies != null ) {
+                        for( def ontology in this.ontologies ) {
+                                if( !otherField.ontologies.contains( ontology ) ) {
+                                        return false
+                                }
+                        }
+                }
+                
+                // If all tests pass, the objects are content-equal
+                return true
+        }
+
+        /**
+         * Create a new template field based on the parsed XML object. 
+         *
+         * @see grails.converters.XML#parse(java.lang.String)
+         * @throws IllegalArgumentException 
+         */
+        public static parse(Object xmlObject, Class entity) {
+                def t = new TemplateField();
+
+                t.name = xmlObject?.name?.text()
+                t.unit = xmlObject?.unit?.text() == "" ? null : xmlObject?.unit?.text()
+                t.comment = xmlObject?.comment?.text()
+                t.required = xmlObject?.required?.text() == 'true' ? true : false
+                t.preferredIdentifier = xmlObject?.preferredIdentifier?.text() == 'true' ? true : false
+
+                t.entity = entity
+
+                t.type = TemplateFieldType.valueOf( xmlObject?.type?.text() )
+
+                // Search for ontologies
+                xmlObject.ontologies?.ontology.each {
+                        def ncboId = it.ncboId?.text();
+                        t.addToOntologies( Ontology.getOrCreateOntologyByNcboId( ncboId ) );
+                }
+
+                // Search for list entries
+                xmlObject.listItems?.listItem.each {
+                        t.addToListEntries( new TemplateFieldListItem( name: it.name?.text() ) );
+                }
+                return t;
+        }
+
+
 }