Export selection to file

    
    /*
    * 
    * Export selected rows button
    *
    * Usage:
    * 1. edit the settings
    * 2. perform a selection of rows
    * 3. execute button script
    *
    * Script will open a "save dialog" for you, where you will need to specify
    * the filename, including the file extension.
    *
    * Please use file extensions supported by MolExporter
    * https://docs.chemaxon.com/display/docs/Molecule+Formats
    * 
    * @author David Pech <dpech@chemaxon.com>
    * improvements of "Export data to SD file" example written by Tim Dudgeon
    * https://docs.chemaxon.com/display/docs/Simple+SDF+Exporter
    */
    import com.im.df.api.*
    import com.im.commons.progress.*
    import chemaxon.struc.Molecule
    import chemaxon.formats.MolExporter;
     
    import javax.swing.filechooser.FileFilter
    import javax.swing.JFileChooser
    
    // -------------------------------- settings -------------------------------------
     
     
    // define what fields to export
    def FIELDS_FROM_PARENT = [ 'Formula', 'Donors', 'Acceptors']
    // define how the fields are going to be renamed (optional)
    def FIELD_NAMES = ['Donors':'My Lovely Donors', 'Acceptors':'My Ugly Acceptors']
    // define the name of filed containing structure
    def STRUCTURE_FIELD = 'Structure'
     
     
    // ------------------- probably not needed to edit anything below ----------------
     
    init = { widget ->
    }
    destroy = { widget ->
    }
    evaluate = { widget ->
        // get to root entity
        def ety = dataTree.rootVertex.entity // assumes you have reference to the data tree
     
        // get the ID field
        def fldId = ety.idField
        println "Found ID field ${fldId.id}"
     
        // get the Structure field
        def molFld = ety.fields.items.find { it.name == STRUCTURE_FIELD } 
        println "Found MOL field ${molFld.id}"
     
        // Get resultsets
        def rs = ety.schema.dataProvider.getDefaultResultSet(dataTree, false, DFEnvironmentRO.DEV_NULL) // find the ResultSet
        def rootVS = rs.getVertexState(dataTree.rootVertex) // obtain the VertexState
        List ids = rootVS.getSelectedRowsIds() // get the IDs of the selection
        // if you want to export all rows always, change the previous line to
        // Lists ids = rootVS.ids
        println "Found ${ids.size} lines to export"
     
     
        // data fields from parent
        def fieldsFromParent = [ ]
        FIELDS_FROM_PARENT.each { name ->
            def fld = ety.fields.items.find { it.name == name }
            if (fld) {
                fieldsFromParent << fld
                println "Found parent field ${fld.id} for $name"
            } else {
                println "WARNING: field $name not found"
            }
        }
     
    
        // lets choose location where to save the file (file format should be supported by https://docs.chemaxon.com/display/docs/Molecule+Formats )
        def saveFileDialog = new JFileChooser(
        dialogTitle: "Choose save location",
        fileSelectionMode: JFileChooser.FILES_ONLY)
        saveFileDialog.showSaveDialog()
     
        // get the full path where to save the file to
        def FILE_NAME = saveFileDialog.getSelectedFile().getAbsolutePath()
     
        // get the extension of the filename 
        def EXTENSION = FILE_NAME.lastIndexOf('.').with {it != -1 ? FILE_NAME.substring(it+1):''}
     
     
        // lets read the data
        def good = 0
        def bad = 0
     
        // and initialize exporter
        // if you need simpler solution, then FILE_NAME and EXTENSION can be hardcoded
        // and saveFileDialog above can be removed
        // coud be used like this instead:
        // def exporter = new MolExporter('C:\path  o\filename.sdf','sdf')
     
        def exporter = new MolExporter(FILE_NAME, EXTENSION)
     
        try {
        ids.each { id ->
     
            try {
                def data = rootVS.getData([id], DFEnvironmentRO.DEV_NULL)
                // get the mol
                def mol = data[id][molFld.id]
                // get the other fields
                def values = [ : ]
                fieldsFromParent.each {
                    values.put(it, data[id][it.id])
                }
     
                println "Exporting ID $id"
     
                def expMol
                // work with a clone so we don't alter the original
                if (!mol || !mol.native ) {
                    expMol = new Molecule()
                } else {
                    expMol = mol.native.cloneMolecule()
                }
                values.each { k,v ->
                    if (v != null) {
                        def pName = (FIELD_NAMES[k.name] == null ? k.name : FIELD_NAMES[k.name])
                        expMol.setProperty(pName, v.toString())
                    }
                }
                exporter.write(expMol)
     
                good++
     
            } catch (Exception exc) {
                println "EROROR Failed to load ID $id ${exc.toString()}"
                bad++
            }
        }
        } finally {
            exporter.flush()
            exporter.close()
        }
        println "Finished exporting data to file $FILE_NAME"
        println "good: $good bad: $bad"
     
    
    }
    on_change = { widget, button ->
    
    }