Changeset 1560

Timestamp:

Feb 24, 2011, 11:59:08 PM (13 years ago)

Author:

j.saito@…

Message:

Added import methods for XML import of studies.

Still not workig (and therefore omitted):

• template Fields (in particular TemplateTermFields?)

Still missing:

• Error handling for clashes and omissions in importing
• Removing unneccessary output of static fields in exporter
• exporting templates (connect to Template exporter)
• Move in Modules for Assay import

File:

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

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

@@ -14 +14 @@
 import dbnp.studycapturing.*
 import grails.converters.XML
+import groovy.util.* 
+import groovy.util.slurpersupport.*
+import groovy.util.slurpersupport.Node as Node 
+import java.util.ArrayList 
 import org.codehaus.groovy.grails.web.converters.configuration.ConvertersConfigurationHolder
+import org.dbnp.bgdt.*
 import org.dbnp.gdt.*
+import org.exolab.castor.xml.Unmarshaller
 
 
@@ -38 +44 @@
      *  List of classes that recursion does not go further into when building an XML  
      *  document; the elements are still included. 
+         *  
+         *  (For importing Study objects)
          *  
          *  @see #getRelatedObjects().
@@ -46 +54 @@
 
 
+    /**
+     *  List of domain classes related to Study.
+     */ 
+        def static DomainClasses = [ 'RegistrationCode':dbnp.authentication.RegistrationCode,
+                        'SecRole':dbnp.authentication.SecRole, 'SecUser':dbnp.authentication.SecUser,
+                        'SecUserSecRole':dbnp.authentication.SecUserSecRole,
+                        'SessionAuthenticatedUser':dbnp.authentication.SessionAuthenticatedUser,
+                        'Assay':dbnp.studycapturing.Assay,
+                        'Book':dbnp.studycapturing.Book,
+                        'Event':dbnp.studycapturing.Event, 'EventGroup':dbnp.studycapturing.EventGroup,
+                        'PersonAffiliation':dbnp.studycapturing.PersonAffiliation,
+                        'Person':dbnp.studycapturing.Person,
+                        'PersonRole':dbnp.studycapturing.PersonRole,
+                        'Publication':dbnp.studycapturing.Publication,
+                        'Sample':dbnp.studycapturing.Sample,
+                        'SamplingEvent':dbnp.studycapturing.SamplingEvent,
+                        'Study':dbnp.studycapturing.Study,
+                        'StudyPerson':dbnp.studycapturing.StudyPerson,
+                        'Subject':dbnp.studycapturing.Subject,
+                        'AssayModule':org.dbnp.gdt.AssayModule,
+                        'Identity':org.dbnp.gdt.Identity,
+                        'RelTime':org.dbnp.gdt.RelTime,
+                        'TemplateEntity':org.dbnp.gdt.TemplateEntity,
+                        'TemplateField':org.dbnp.gdt.TemplateField,
+                        'TemplateFieldListItem':org.dbnp.gdt.TemplateFieldListItem,
+                        'TemplateFieldType':org.dbnp.gdt.TemplateFieldType,
+                        'Template':org.dbnp.gdt.Template ]
+
+
         /** 
          *  Returns a list of all Grails domain objects relevant for creating a full
@@ -98 +135 @@
                 if( domainClass.toString()==~/class dbnp.authentication.SecUser.+/ || 
                     domainClass.toString()==~/class dbnp.studycapturing.Publication.+/ ) {
-                        println "${domainClass} -- ${domainObject}"
                         return objects 
                 }
@@ -111 +147 @@
 
                                                                                                 // enter recursion with regular domain fields
-                domainObject.getProperties().domainFields.each { field ->
+                domainObject.properties.domainFields.each { field ->
                         objects.addAll( getRelatedObjects(field) )
                 }
@@ -131 +167 @@
 
 
-        /** 
-         *  Returns Study object from List of objects created by 
-         *  XML representation of a Study.
-         *  
-         *  @param List of objects 
-         *
-         *  @return Study object that has to be saved 
-         *
-         *  @see getDependentObjects()
-         */ 
-
-        def     getStudy( Collection objectList ) {
-        }
-
 
 
@@ -158 +180 @@
          */ 
 
-        def     parseXMLStudy( XML xml ) {
+        def     parseXMLStudy() {
+                XML.parse(new FileInputStream('/tmp/test.xml'), "UTF-8")
+        }
+
+
+
+        def     parseXMLStudyList( GPathResult result ) {
+                def parseObjects = 
+                        result.childNodes().collect { 
+                                new ParseObject(it) 
+                        }               
+                def study = createStudy( parseObjects ) 
+                study.save()    
+        }
+
+
+
+
+        /** 
+         *  Create Study from list of objects repesenting a Study. 
+         *  
+         *  (For importing Study objects)
+         *  
+         *  @param  List of objects representing a Study. 
+         *
+         *  @return void
+         */ 
+
+        def createStudy( List parseObjects ) {
+                parseObjects.each{ 
+                        populateFields( 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
+                                }
+                        }
+                }
+
+                def newDomainObject = domainObject.class.newInstance(map)
+                newDomainObject.id = 0
+                domainObject = newDomainObject
+        }
+
+
+
+        /** 
+         *  Populate one-to-many maps of a new domainObject  
+         *  from list of ParseObjects. 
+         *  
+         *  (For importing Study objects)
+         *  
+         *  @param domainObject   domainObject to be fielled  
+         *  
+         *  @param  List of parseObjects representing a Study. 
+         *
+         *  @return the new domainObject 
+         */ 
+        
+        def populateOneToManies( domainObject, node, parseObjects ) {
+                if( !domainObject.class.metaClass.getProperties().find{ it.name=='hasMany' } ) {
+                        return
+                }
+
+                domainObject.class.hasMany.each{ name, theClass ->
+                        node.children().each { child -> 
+                                if(child.name==name) {
+                                        child.children().each { grandChild ->
+                                                def id = grandChild.attributes.id
+                                                if(id) {
+                                                        def ref = parseObjects.find{ it.theClass==theClass && it.id==id }
+                                                        if(ref) {
+                                                                def addTo = "addTo" + name.replaceFirst(name[0],name[0].toUpperCase()) 
+                                                                domainObject.invokeMethod(addTo,(Object) ref.domainObject )
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+
+        def populateTemplateFields( domainObject, Node node, List parseObjects ) {
+        }
+
+
+
+        /** 
+         *  Populate one-to-many maps of a new domainObject  
+         *  from list of ParseObjects. 
+         *
+         *  (For importing Study objects)
+         *
+         *  @param domainObject   domainObject to be fielled  
+         *  
+         *  @param  List of parseObjects representing a Study. 
+         *
+         *  @return the new domainObject 
+         */ 
+
+        private class ParseObject { 
+                String tag
+                String id
+                Class theClass 
+                Object domainObject
+                groovy.util.slurpersupport.Node node
+        
+
+                public ParseObject( node ){
+                        tag = node.name()
+                        theClass = getClassForTag( tag ) 
+                        domainObject = theClass.newInstance() 
+                        id = null
+                        if(node.attributes && node.attributes.id) {
+                                id = node.attributes.id
+                        }
+                        this.node=node
+                }
+
+                private static getClassForTag( String tag ) {
+                        def shortName = tag.replaceFirst( tag[0], tag[0].toUpperCase() )
+                        return DomainClasses[ shortName ] 
+                }
+
         }