Changeset 1568

Timestamp:

Feb 25, 2011, 4:55:05 PM (12 years ago)

Author:

j.saito@…

Message:

Added support for matching tempaltes that are present in system.
In this way, template related information can in principle be imported, if the template is known in the current application.

File:

• trunk/grails-app/services/dbnp/studyexport/ExportService.groovy (modified) (7 diffs)

trunk/grails-app/services/dbnp/studyexport/ExportService.groovy

@@ -121 +121 @@
                 def objects = []
 
+
                 if( IgnoredClasses.contains(domainClass) )   {
                         return objects 
@@ -131 +132 @@
 
 
+                if(domainObject instanceof TemplateEntity ) {
+                        objects.push(domainObject.template)
+                        domainObject.template.fields.each { objects.push(it) }
+                }
+
 
                 if( TerminalClasses.contains(domainClass) )  {
-                        return [domainObject]
-                }
-
-                objects = [domainObject]
+                        objects.push(domainObject)
+                        return objects 
+                }
+
+                objects.push(domainObject)
 
                                                                                                 // enter recursion with regular domain fields
@@ -199 +206 @@
          *  @return void
          */ 
-
         def createStudy( List parseObjects ) {
                 parseObjects.each{ 
-                        populateFields( it.domainObject, it.node, parseObjects )
+                        populateOneToManies( it.domainObject, it.node, parseObjects )
                 }
                 parseObjects.each{ 
-                        populateOneToManies( it.domainObject, it.node, parseObjects )
-                }
-                parseObjects.each{ 
-                        populateTemplateFields( it.domainObject, it.node, parseObjects )
-                }
-        }
-
-
-
-        /** 
-         *  Populate fields of a domainObject to be created.
-         *  The fields of a new object are filled with simple Class objects.
-         *  
-         *  (For importing Study objects)
-         *  
-         *  @param domainObject   The Object to be fielled  
-         *  
-         *  @param  List of ParseObjects representing a Study. 
-         *
-         *  @return the new domainObject 
-         */ 
-
-        def populateFields( domainObject, node, List parseObjects ) {
-
-                def fields = 
-                        domainObject.getProperties().domainFields.collect { it.toString() }
-
-                def map = [:]
-                domainObject.metaClass.getProperties().each { property ->
-                        def name = property.name
-                        def field = fields.find{ it == name }
-
-                        if(field) { 
-                                def type = property.type
-                                def value = node.children().find{ it.name == field }.text()
-
-                                switch(type) {
-                                        case String: map[field]=value; break
-                                        case Date: map[field] = Date.parse( 'yyyy-MM-dd', value ); break
+                        if( it.domainObject instanceof TemplateEntity ) {
+                                addTemplateRelations( it.domainObject, it.node, parseObjects )
+                                addTemplateFields( it.domainObject, it.node, parseObjects )
+                        }
+                }
+        }
+
+
+        /** Set a TemplateEntity's template field. Find the right Template in the list  
+          *     of ParseObjects based on parsed id. If the TemplateEntity instance does
+          * not have an matching template in the list of ParseObjects, it remains empty.
+          *
+          * @param domainObject Some Template Entity
+          *
+          * @param node Node with parse information
+          *
+          * @param parseObjects List of ParseObjects 
+          */
+        def addTemplateRelations( TemplateEntity domainObject, Node node, List parseObjects ) {
+                def id = node.children().find{it.name=='template'}?.attributes()?.id
+                if(id) {
+                        def template = parseObjects.find{ it.theClass==Template && it.id==id }?.domainObject
+                        if(template) {
+                                domainObject.template = template
+                        }
+                }
+        }
+
+
+
+        /** Set a TemplateEntity's template fields with values from a Node. 
+          * The template fields are fields such as TemplateStringField or TemplateFieldType.
+          *
+          * @param domainObject Some Template Entity
+          *
+          * @param node Node with parse information
+          *
+          */
+        def addTemplateFields( TemplateEntity domainObject, Node node ) {
+                domainObject.metaClass.getProperties().each{ property ->
+                        def name = property.name      // name of templateFields, e.g., templateStringFields
+                        if( name ==~/template(.+)Fields/ ) {
+                                node.children().find{it.name==name}?.children()?.each{ fieldNode ->     
+                                        def key = fieldNode.attributes()?.key
+                                        def value = fieldNode.text()
+                                        //domainObject.setFieldValue(key,value)  -> needs to be fixed based on class/type
                                 }
                         }
                 }
-
-                def newDomainObject = domainObject.class.newInstance(map)
-                newDomainObject.id = 0
-                domainObject = newDomainObject
         }
 
@@ -267 +276 @@
          *  @return the new domainObject 
          */ 
-        
         def populateOneToManies( domainObject, node, parseObjects ) {
                 if( !domainObject.class.metaClass.getProperties().find{ it.name=='hasMany' } ) {
@@ -292 +300 @@
 
 
-        def populateTemplateFields( domainObject, Node node, List parseObjects ) {
-        }
-
-
-
-        /** 
-         *  Populate one-to-many maps of a new domainObject  
-         *  from list of ParseObjects. 
+
+        /** 
+         *  Populate one-to-many maps of a new domainObject  from list of ParseObjects. 
          *
          *  (For importing Study objects)
@@ -315 +318 @@
                 Class theClass 
                 Object domainObject
-                groovy.util.slurpersupport.Node node
-        
+                Node node
+
 
                 public ParseObject( node ){
@@ -327 +330 @@
                         }
                         this.node=node
-                }
-
-                private static getClassForTag( String tag ) {
-                        def shortName = tag.replaceFirst( tag[0], tag[0].toUpperCase() )
-                        return DomainClasses[ shortName ] 
-                }
-
-        }
+
+                        if(theClass==Template) {
+                                                                // Templates are suppsed to have been imported before 
+                                                                // importing a study. Study.template is matched to a
+                                                                // Template by the template's name.
+                                def child = node.children.find{ "name"==it.name }
+                                domainObject = Template.findByName( child.text() )
+                        }
+                        else { 
+                                setSimpleFields()
+                        }
+                }
+
+
+
+                /** 
+                 *  Populate this.domainObject's String and Date fields of 
+                 *  a domainObject from parsed XML node.
+                 */ 
+                private void setSimpleFields() {
+
+                        def fields = 
+                                domainObject.getProperties().domainFields.collect { it.toString() }
+
+                        def map = [:]
+                        domainObject.metaClass.getProperties().each { property ->
+                                def name = property.name
+                                def field = fields.find{ it == name }
+
+                                if(field) { 
+                                        def type = property.type
+                                        def value = node.children().find{ it.name == field }.text()
+
+                                        switch(type) {
+                                                case String: map[field]=value; break
+                                                case Date: map[field] = Date.parse( 'yyyy-MM-dd', value ); break
+                                                //case Boolean: ???; break
+                                        }
+                                }
+                        }
+
+                        def newDomainObject = domainObject.class.newInstance(map)
+                        newDomainObject.id = 1  // neccessary?
+                        domainObject = newDomainObject
+                }
+
+        }
+
 
 }