Drop Down Input Dialog

/** Add annotations to an Invention button, from the Invention form
*
* @author Erin Bolstad (ebolstad@chemaxon.com)
* Dec 2011
*/

import com.im.df.api.dml.*
import com.im.commons.progress.*
import groovy.swing.SwingBuilder
import com.im.df.api.util.DIFUtilities
import java.awt.*
import org.openide.NotifyDescriptor
import org.openide.DialogDisplayer

evaluate = { widget ->

    def rs = widget.form.resultSet
    def dataTree = rs.dataTree
    def ety = dataTree.rootVertex.entity
    def parentVS = rs.rootVertexState
    def schema = ety.schema

    def VMNSvertex = dataTree.rootVertex.edges.find { it.destination.entity.name == 'VMNS' }
    def inventionVertex = VMNSvertex.destination.edges.find { it.destination.entity.name == 'Inventions' }
    def invenV = inventionVertex.getDestination()
    def invenVS = rs.getVertexState(invenV)
    def invenIds = invenVS.selectedRowsIds
    def invenFirstId = invenIds.get(0)

    def noteEdge = inventionVertex.destination.edges.find { it.destination.entity.name == 'Notes' }
    def noteEntity = noteEdge.destination.entity
    def noteEdp = noteEntity.schema.dataProvider.getEntityDataProvider(noteEntity)
    def noteRS = noteEntity.schema.dataProvider.getDefaultResultSet(dataTree, true, DFEnvironmentRO.DEV_NULL)
    def noteVS = noteRS.getVertexState(noteEdge.destination)

    noteEdp.lockable.withLock('Notating') { envRW ->

        def noteIDs = noteEdp.queryForIds(DFTermExpression.ALL_DATA, null, envRW)
        def noteData = noteVS.getData(noteIDs, envRW)
        def noteFld = noteEntity.fields.items.find { it.name == 'NOTE' }
        def noteUserFld = noteEntity.fields.items.find { it.name == 'User' }
        def noteDateFld = noteEntity.fields.items.find { it.name == 'Date Added' }

        noteRef = [:]
        noteList = ["-"]

        noteData.each { id, noteMap ->
            notetation = noteData[id][noteFld.id]
            noteRef.putAt(id, notetation)
            noteList << notetation
        }
        def noteSel = new SwingBuilder()

        noteSel.setVariable('properties',[:])

        def vars = noteSel.variables

        def frame = noteSel.dialog(title:'Notations', modal:true) {
            panel () {
                gridBagLayout()
                label(text:"Enter a new notation:", constraints:gbc(
                        gridx:0,
                        gridy:0,
                        insets:[10,10,10,5]))
                textField(id:'newName', constraints:gbc(
                        gridx:1,
                        gridy:0,
                        fill:GridBagConstraints.HORIZONTAL,
                        insets:[10,10,10,10]))
                label(text:" Or, select an existing notation from the list", constraints:gbc(
                        gridy:1,
                        gridwidth:2,
                        insets:[10,50,5,50]))
                comboBox(id:'notetations', items:noteList, constraints:gbc(
                        gridy:2,
                        gridwidth:2,
                        insets:[5,10,10,10]))
                button(id:'ok', label: "OK", constraints:gbc(
                        gridx:0,
                        gridy:3,
                        anchor:LINE_END,
                        insets:[10,0,10,0]),
                        actionPerformed: {
                            vars.buttonResults = 'ok'
                            dispose()})
                button(id:'cancel', label: "Cancel", constraints:gbc(
                        gridx:1,
                        gridy:3,
                        anchor:LINE_START,
                        insets:[10,0,10,0]),
                        actionPerformed: {
                            vars.buttonResults = 'quit'
                            dispose()})
            }
        }

        frame.pack()
        frame.setLocationRelativeTo(null)
        frame.show()

        def chosenAction = vars.buttonResults

        if (chosenAction == 'quit') {
            return
        }

        if (chosenAction == 'ok') {
            newNotetation = vars.newName.text
            selNotetation = vars.notetations.selectedItem
        }

        rel = DIFUtilities.findUsagesInRelationships(noteEntity)
        firstRel = rel.get(0)

        //Get current invention ID - make relationship with only that one.

        def userName = schema.getUsername()
        def timeStamp = new Date()

        if (selNotetation == "-") {

            // See if Notation already exists, throw warning message

            def newNoteIDs = noteEdp.queryForIds(DFTermExpression.ALL_DATA, null, envRW)
            def newNoteData = noteVS.getData(newNoteIDs, envRW)

            newNoteRef = [:]
            newNoteList = ["-"]

            if (!newNoteData.isEmpty()) {
                newNoteData.each { id, noteMap ->
                    notetation = newNoteData[id][noteFld.id]
                    newNoteRef.putAt(id, notetation)
                    newNoteList << notetation
                }
            }

            if (newNoteList.contains(newNotetation)) {
                def message1 = "$newNotetation already exists!\nCheck the drop down box"
                NotifyDescriptor w = new NotifyDescriptor.Message(message1)
                DialogDisplayer.getDefault().notify(w)
                return

            }else{
                vals =[(noteFld.id):newNotetation]
                vals.putAt(noteUserFld.id, userName)
                vals.putAt(noteDateFld.id, timeStamp)
                noteEdp.insert(vals, null, envRW)
                def insNoteIDs = noteEdp.queryForIds(DFTermExpression.ALL_DATA, null, envRW)
                def insNoteData = noteVS.getData(insNoteIDs, envRW)
                newNoteRef = [:]

                insNoteData.each { id, noteMap ->
                    notetation = insNoteData[id][noteFld.id]
                    newNoteRef.putAt(id, notetation)
                }
                newLastKey = newNoteRef.max{ it.key }
                newIdx = newLastKey.key
                def x = ("$newIdx" as String) as Integer
                def y = ("$invenFirstId" as String) as Object

                DIFUtilities.connectRelationalData(firstRel.forward, y, x, envRW)

                def message = "Please Note:\nTo see this new Note in the Notation View,\nyou will first need to select 'Show All' in Query mode."
                NotifyDescriptor d = new NotifyDescriptor.Message(message)
                DialogDisplayer.getDefault().notify(d)
            }
        }

        if (selNotetation != "-") {
            def selKeySet = noteRef.find { id, notet -> notet == selNotetation}
            def selNoteID = selKeySet.key

            // Get the note IDs for the invention in question
            def checkIDs = noteVS.getIdsForParentId(invenFirstId, DFEnvironmentRO.DEV_NULL)

            if (checkIDs.contains(selNoteID)) {
                def message2 = "$selNotetation already assigned to Invention $invenFirstId!"
                NotifyDescriptor q = new NotifyDescriptor.Message(message2)
                DialogDisplayer.getDefault().notify(q)
                return
            } else {
                def x = ("$selNoteID" as String) as Integer
                def y = ("$invenFirstId" as String) as Object
                DIFUtilities.connectRelationalData(firstRel.forward, y, x, envRW)
            }
        }
    }

}