Changeset 1609


Ignore:
Timestamp:
Mar 9, 2011, 5:28:45 PM (6 years ago)
Author:
robert@…
Message:

Improved simple editing wizard

Location:
trunk/grails-app
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/studycapturing/SimpleWizardController.groovy

    r1608 r1609  
    115115                samples {
    116116                        on("next") {
    117                                 handleSamples( flow.study, params, flow ) ? success() : error ()
     117                                if( !handleSamples( flow.study, params, flow ) )
     118                                        return error();
    118119                               
    119120                                // Add domain fields for all entities
     
    125126                                        }
    126127                                }
    127 
     128                               
     129                                println flow.sampleForm.template
    128130                        }.to "columns"
     131                        on("refresh") {
     132                                def filename = params.get( 'importfile' );
     133               
     134                                // Handle 'existing*' in front of the filename. This is put in front to make a distinction between
     135                                // an already uploaded file test.txt (maybe moved to some other directory) and a newly uploaded file test.txt
     136                                // still being in the temporary directory.
     137                                // This import step doesn't have to make that distinction, since all files remain in the temporary directory.
     138                                if( filename == 'existing*' )
     139                                        filename = '';
     140                                else if( filename[0..8] == 'existing*' )
     141                                        filename = filename[9..-1]
     142                               
     143                                // Refresh the templates, since the template editor has been opened
     144                                flow.templates = [
     145                                                'Sample': Template.findAllByEntity( Sample.class ),
     146                                                'Subject': Template.findAllByEntity( Subject.class ),
     147                                                'Event': Template.findAllByEntity( Event.class ),
     148                                                'SamplingEvent': Template.findAllByEntity( SamplingEvent.class )
     149                                ];
     150                                                                               
     151                                flow.sampleForm = [ importFile: filename ]
     152                        }.to "samples"
    129153                        on("previous").to "returnFromSamples"
    130154                        on("study").to "study"
     
    457481                                                'Subject': subjectTemplateId,
    458482                                                'Event': eventTemplateId,
    459                                                 'SampingEvent': samplingEventTemplateId
     483                                                'SamplingEvent': samplingEventTemplateId
    460484                                        ],
    461485                                        template: [
     
    463487                                                'Subject': subjectTemplateId ? Template.get( subjectTemplateId ) : null,
    464488                                                'Event': eventTemplateId ? Template.get( eventTemplateId ) : null,
    465                                                 'SampingEvent': samplingEventTemplateId ? Template.get( samplingEventTemplateId ) : null
     489                                                'SamplingEvent': samplingEventTemplateId ? Template.get( samplingEventTemplateId ) : null
    466490                                        ],
    467491                                        sheetIndex: sheetIndex,
     
    663687                        return false
    664688                }
    665                
    666                
     689                       
    667690                def imported = importerService.importOrUpdateDataBySampleIdentifier(templates,
    668691                                workbook,
     
    699722                                        switch( entity.class ) {
    700723                                                case Sample:
    701                                                         if( preferredIdentifier && !study.samples?.find( equalClosure ) ) {
     724                                                        if( !preferredIdentifier || !study.samples?.find( equalClosure ) ) {
    702725                                                                study.addToSamples( entity );
    703726                                                        }
    704727                                                        break;
    705728                                                case Subject:
    706                                                         if( preferredIdentifier && !study.subjects?.find( equalClosure ) ) {
     729                                                        if( !preferredIdentifier || !study.subjects?.find( equalClosure ) ) {
    707730                                                                study.addToSubjects( entity );
    708731                                                        }
    709732                                                        break;
    710733                                                case Event:
    711                                                         if( preferredIdentifier && !study.events?.find( equalClosure ) ) {
     734                                                        if( !preferredIdentifier || !study.events?.find( equalClosure ) ) {
    712735                                                                study.addToEvents( entity );
    713736                                                        }
    714737                                                        break;
    715738                                                case SamplingEvent:
    716                                                         if( preferredIdentifier && !study.samplingEvents?.find( equalClosure ) ) {
     739                                                        if( !preferredIdentifier || !study.samplingEvents?.find( equalClosure ) ) {
    717740                                                                study.addToSamplingEvents( entity );
    718741                                                        }
  • trunk/grails-app/services/dbnp/importer/ImporterService.groovy

    r1608 r1609  
    6969                                        try {
    7070                                                formatValue(datamatrix_celldata, TemplateFieldType.DOUBLE)
    71                                         } catch (NumberFormatException nfe) { doubleBoolean = false }
     71                                        } catch (NumberFormatException nfe) {
     72                                                doubleBoolean = false
     73                                        }
    7274                                        finally {
    7375                                                if (doubleBoolean) fieldtype = TemplateFieldType.DOUBLE
     
    8991                                        try {
    9092                                                Long.valueOf(datamatrix_celldata)
    91                                         } catch (NumberFormatException nfe) { longBoolean = false }
     93                                        } catch (NumberFormatException nfe) {
     94                                                longBoolean = false
     95                                        }
    9296                                        finally {
    9397                                                if (longBoolean) fieldtype = TemplateFieldType.LONG
     
    98102                                                try {
    99103                                                        formatValue(datamatrix_celldata, TemplateFieldType.DOUBLE)
    100                                                 } catch (NumberFormatException nfe) { doubleBoolean = false }
     104                                                } catch (NumberFormatException nfe) {
     105                                                        doubleBoolean = false
     106                                                }
    101107                                                finally {
    102108                                                        if (doubleBoolean) fieldtype = TemplateFieldType.DOUBLE
     
    187193        }
    188194
    189        
     195
    190196        /**
    191197         * Retrieves records with sample, subject, samplingevent etc. from a study
     
    195201        protected def getRecords( Study s ) {
    196202                def records = [];
    197                
     203
    198204                s.samples?.each {
    199205                        def record = [ 'objects': retrieveEntitiesBySample( it ) ];
    200                
     206
    201207                        def templates = [:]
    202208                        def templateCombination = [];
     
    206212                                        templateCombination << entity.key + ": " + entity.value?.template?.name;
    207213                        }
    208                        
     214
    209215                        record.templates = templates;
    210216                        record.templateCombination = templateCombination.join( ', ' )
    211                        
     217
    212218                        records << record
    213219                }
    214                
     220
    215221                return records;
    216222        }
    217        
     223
    218224        /**
    219225         * Returns a subject, event and samplingEvent that belong to this sample
     
    229235                ]
    230236        }
    231        
     237
    232238        /**
    233239         * Imports data from a workbook into a list of ImportRecords. If some entities are already in the database,
     
    252258                if( !mcmap )
    253259                        return;
    254                        
     260
    255261                // Check whether the rows should be imported in one or more entities
    256262                def entities
     
    260266                        entities = mcmap.findAll{ !it.dontimport }.entityclass.unique();
    261267                }
    262                
     268
    263269                def sheet = wb.getSheetAt(sheetindex)
    264270                def table = []
    265271                def failedcells = [] // list of cells that have failed to import
    266 
    267272                // First check for each record whether an entity in the database should be updated,
    268273                // or a new entity should be added. This is done before any new object is created, since
     
    274279                        existingEntities[i] = findExistingEntities( entities, sheet.getRow(i), mcmap, parent );
    275280                }
    276                                
     281
    277282                // walk through all rows and fill the table with records
    278283                for( int i = rowindex; i <= sheet.getLastRowNum(); i++ ) {
    279284                        // Create an entity record based on a row read from Excel and store the cells which failed to be mapped
    280285                        def (record, failed) = importOrUpdateRecord( templates, entities, sheet.getRow(i), mcmap, parent, table, existingEntities[i] );
    281                        
     286
    282287                        // Setup the relationships between the imported entities
    283288                        relateEntities( record );
    284                        
     289
    285290                        // Add record with entities and its values to the table
    286291                        table.add(record)
     
    289294                        if (failed?.importcells?.size() > 0) failedcells.add(failed)
    290295                }
    291                
     296
    292297                return [ "table": table, "failedCells": failedcells ]
    293298        }
    294299
    295300        /**
    296         * Checks whether entities in the given row already exist in the database
    297         * they are updated.
    298         *
    299         * @param        entities        Entities that have to be imported for this row
    300         * @param        excelRow        Excel row to import into this record
    301         * @param        mcmap           Hashmap of mappingcolumns, with the first entry in the hashmap containing information about the first column, etc.
    302         * @return       Map                     Map with entities that have been found for this row. The key for the entities is the entity name (e.g.: [Sample: null, Subject: <subject object>]
    303         */
    304    def findExistingEntities(def entities, Row excelRow, mcmap, parent ) {
    305            DataFormatter df = new DataFormatter();
    306 
    307            // Find entities based on sample identifier
    308            def sample = findEntityByRow( dbnp.studycapturing.Sample, excelRow, mcmap, parent, [], df );
    309            return retrieveEntitiesBySample( sample );
    310    }
    311    
     301         * Checks whether entities in the given row already exist in the database
     302         * they are updated.
     303         *
     304         * @param       entities        Entities that have to be imported for this row
     305         * @param       excelRow        Excel row to import into this record
     306         * @param       mcmap           Hashmap of mappingcolumns, with the first entry in the hashmap containing information about the first column, etc.
     307         * @return      Map                     Map with entities that have been found for this row. The key for the entities is the entity name (e.g.: [Sample: null, Subject: <subject object>]
     308         */
     309        def findExistingEntities(def entities, Row excelRow, mcmap, parent ) {
     310                DataFormatter df = new DataFormatter();
     311
     312                // Find entities based on sample identifier
     313                def sample = findEntityByRow( dbnp.studycapturing.Sample, excelRow, mcmap, parent, [], df );
     314                return retrieveEntitiesBySample( sample );
     315        }
     316
    312317        /**
    313318         * Imports a records from the excelsheet into the database. If the entities are already in the database
     
    332337                def record = [] // list of entities and the read values
    333338                def failed = new ImportRecord() // map with entity identifier and failed mappingcolumn
    334        
     339
    335340                // Check whether this record mentions a sample that has been imported before. In that case,
    336341                // we update that record, in order to prevent importing the same sample multiple times
     
    341346                def importedSample = null // findEntityInImportedEntities( dbnp.studycapturing.Sample, excelRow, mcmap, importedEntities, df )
    342347                def imported = [] // retrieveEntitiesBySample( importedSample );
    343                
    344348                for( entity in entities ) {
    345349                        // Check whether this entity should be added or updated
     
    348352                        def entityName = entity.name[ entity.name.lastIndexOf( '.' ) + 1..-1];
    349353                        def template = templates[ entityName ];
    350                        
     354
    351355                        // If no template is specified for this entity, continue with the next
    352356                        if( !template )
    353357                                continue;
    354                        
     358
    355359                        // Check whether the object exists in the list of already imported entities
    356360                        def entityObject = imported[ entityName ]
    357                        
     361
    358362                        // If it doesn't, search for the entity in the database
    359363                        if( !entityObject && existingEntities )
    360364                                entityObject = existingEntities[ entityName ];
    361                        
     365
    362366                        // Otherwise, create a new object
    363367                        if( !entityObject )
    364368                                entityObject = entity.newInstance();
    365                        
     369
    366370                        // Update the template
    367371                        entityObject.template = template;
    368                        
     372
    369373                        // Go through the Excel row cell by cell
    370374                        for (Cell cell: excelRow) {
     
    372376                                def mc = mcmap[cell.getColumnIndex()]
    373377                                def value
    374          
     378
    375379                                // Check if column must be imported
    376380                                if (mc != null && !mc.dontimport && mc.entityclass == entity) {
     
    380384                                                value = ""
    381385                                        }
    382          
     386
    383387                                        try {
    384388                                                entityObject.setFieldValue(mc.property, value)
     
    388392                                                // store the mapping column and value which failed
    389393                                                def identifier = entityName.toLowerCase() + "_" + entityObject.getIdentifier() + "_" + mc.property
    390          
     394
    391395                                                def mcInstance = new MappingColumn()
    392396                                                mcInstance.properties = mc.properties
     
    395399                                } // end if
    396400                        } // end for
    397                        
     401
    398402                        // If a Study is entered, use it as a 'parent' for other entities
    399403                        if( entity == Study )
    400404                                parent = entityObject;
    401                        
     405
    402406                        record << entityObject;
    403407                }
    404                
     408
    405409                // a failed column means that using the entity.setFieldValue() threw an exception
    406410                return [record, failed]
    407411        }
    408        
     412
    409413        /**
    410414         * Looks into the database to find an object of the given entity that should be updated, given the excel row.
     
    424428                if( df == null )
    425429                        df = new DataFormatter();
    426                        
     430
    427431                def identifierField = givePreferredIdentifier( entity );
    428                
     432
    429433                if( identifierField ) {
    430434                        // Check whether the identifierField is chosen in the column matching
    431435                        def identifierColumn = mcmap.find { it.entityclass == entity && it.property == identifierField.name };
    432                        
     436
    433437                        // If it is, find the identifier and look it up in the database
    434438                        if( identifierColumn ) {
     
    440444                                        identifier = null
    441445                                }
    442                                
     446
    443447                                // Search for an existing object with the same identifier.
    444448                                if( identifier ) {
     
    449453                                                        return imported;
    450454                                        }
    451                                        
     455
    452456                                        def c = entity.createCriteria();
    453                                        
     457
    454458                                        // If the entity has a field 'parent', the search should be limited to
    455459                                        // objects with the same parent. The method entity.hasProperty( "parent" ) doesn't
     
    458462                                                // If the entity requires a parent, but none is given, no
    459463                                                // results are given from the database. This prevents the user
    460                                                 // of changing data in another study 
     464                                                // of changing data in another study
    461465                                                if( parent && parent.id ) {
    462466                                                        println "Searching (with parent ) for " + entity.name + " with " + identifierField.name + " = " + identifier
     
    475479                        }
    476480                }
    477                
     481
    478482                // No object is found
    479483                return null;
    480484        }
    481        
    482         /**
    483         * Looks into the list of already imported entities to find an object of the given entity that should be
    484         * updated, given the excel row. This is done by looking at the 'preferredIdentifier' field of the object.
    485         * If it exists in the row, and the list of imported entities contains an object with the same
    486         * identifier, the existing object is returned. Otherwise, null is returned
    487         *
    488         * @param        entity          Entity to search
    489         * @param        excelRow        Excelrow to search for
    490         * @param        mcmap           Map with MappingColumns
    491         * @param        importedRows    List of entities that have been imported before. The function will first look through this list to find
    492         *                                                       a matching entity.
    493         * @return       An entity that has the same identifier as entered in the excelRow. The entity is first sought in the importedRows. If it
    494         *                       is not found there, the database is queried. If no entity is found at all, null is returned.
    495         */
    496    def findEntityInImportedEntities( Class entity, Row excelRow, def mcmap, List importedEntities = [], DataFormatter df = null ) {
    497            if( df == null )
    498                    df = new DataFormatter();
    499                    
    500            def allFields = entity.giveDomainFields();
    501            def identifierField = allFields.find { it.preferredIdentifier }
    502            
    503            if( identifierField ) {
    504                    // Check whether the identifierField is chosen in the column matching
    505                    def identifierColumn = mcmap.find { it.entityclass == entity && it.property == identifierField.name };
    506                    
    507                    // If it is, find the identifier and look it up in the database
    508                    if( identifierColumn ) {
    509                            def identifierCell = excelRow.getCell( identifierColumn.index );
    510                            def identifier;
    511                            try {
    512                                    identifier = formatValue(df.formatCellValue(identifierCell), identifierColumn.templatefieldtype)
    513                            } catch (NumberFormatException nfe) {
    514                                    identifier = null
    515                            }
    516                            
    517                            // Search for an existing object with the same identifier.
    518                            if( identifier ) {
     485
     486        /**
     487         * Looks into the list of already imported entities to find an object of the given entity that should be
     488         * updated, given the excel row. This is done by looking at the 'preferredIdentifier' field of the object.
     489         * If it exists in the row, and the list of imported entities contains an object with the same
     490         * identifier, the existing object is returned. Otherwise, null is returned
     491         *
     492         * @param       entity          Entity to search
     493         * @param       excelRow        Excelrow to search for
     494         * @param       mcmap           Map with MappingColumns
     495         * @param       importedRows    List of entities that have been imported before. The function will first look through this list to find
     496         *                                                      a matching entity.
     497         * @return      An entity that has the same identifier as entered in the excelRow. The entity is first sought in the importedRows. If it
     498         *                      is not found there, the database is queried. If no entity is found at all, null is returned.
     499         */
     500        def findEntityInImportedEntities( Class entity, Row excelRow, def mcmap, List importedEntities = [], DataFormatter df = null ) {
     501                if( df == null )
     502                        df = new DataFormatter();
     503
     504                def allFields = entity.giveDomainFields();
     505                def identifierField = allFields.find { it.preferredIdentifier }
     506
     507                if( identifierField ) {
     508                        // Check whether the identifierField is chosen in the column matching
     509                        def identifierColumn = mcmap.find { it.entityclass == entity && it.property == identifierField.name };
     510
     511                        // If it is, find the identifier and look it up in the database
     512                        if( identifierColumn ) {
     513                                def identifierCell = excelRow.getCell( identifierColumn.index );
     514                                def identifier;
     515                                try {
     516                                        identifier = formatValue(df.formatCellValue(identifierCell), identifierColumn.templatefieldtype)
     517                                } catch (NumberFormatException nfe) {
     518                                        identifier = null
     519                                }
     520
     521                                // Search for an existing object with the same identifier.
     522                                if( identifier ) {
    519523                                        // First search the already imported rows
    520524                                        if( importedEntities ) {
     
    526530                                                        else
    527531                                                                return fieldValue == identifier
    528 
    529532                                                };
    530                                            if( imported )
    531                                                    return imported;
    532                                    }
    533                            }
    534                    }
    535            }
    536            
    537            // No object is found
    538            return null;
    539    }
    540 
    541        
     533                                                if( imported )
     534                                                        return imported;
     535                                        }
     536                                }
     537                        }
     538                }
     539
     540                // No object is found
     541                return null;
     542        }
     543
     544
    542545        /**
    543546         * Creates relation between multiple entities that have been imported. The entities are
     
    551554                def samplingEvent = entities.find { it instanceof SamplingEvent }
    552555                def assay = entities.find { it instanceof Assay }
    553                
     556
    554557                // A study object is found in the entity list
    555558                if( study ) {
     
    563566                        }
    564567                        if( event ) {
    565                                 event.parent = study 
     568                                event.parent = study
    566569                                study.addToEvents( event );
    567570                        }
     
    584587                                if( subject ) evGroup.addToSubjects( subject );
    585588                                if( samplingEvent ) evGroup.addToSamplingEvents( samplingEvent );
    586                                
     589
    587590                                sample.parentEventGroup = evGroup;
    588591                        }
    589                        
     592
    590593                        if( assay ) assay.addToSamples( sample );
    591594                }
     
    610613                def table = []
    611614                def failedcells = [] // list of records
    612                
    613615                // walk through all rows and fill the table with records
    614616                (rowindex..sheet.getLastRowNum()).each { i ->
     
    665667        def getFieldNameInTableEditor(entity, field) {
    666668                def entityName = entity?.class.name[ entity?.class.name.lastIndexOf(".") + 1..-1]
    667                
     669
    668670                if( field instanceof TemplateField )
    669671                        field = field.escapedName();
    670672
    671                 return entityName.toLowerCase() + "_" + entity.getIdentifier() + "_" + field
     673                return entityName.toLowerCase() + "_" + entity.getIdentifier() + "_" + field.toLowerCase()
    672674        }
    673675
     
    928930                                        // store the mapping column and value which failed
    929931                                        def identifier
    930 
     932                                        def fieldName = mc.property?.toLowerCase()
     933                                       
    931934                                        switch (mc.entityclass) {
    932                                                 case Study: identifier = "entity_" + study.getIdentifier() + "_" + mc.property
    933                                                         break
    934                                                 case Subject: identifier = "entity_" + subject.getIdentifier() + "_" + mc.property
    935                                                         break
    936                                                 case SamplingEvent: identifier = "entity_" + samplingEvent.getIdentifier() + "_" + mc.property
    937                                                         break
    938                                                 case Event: identifier = "entity_" + event.getIdentifier() + "_" + mc.property
    939                                                         break
    940                                                 case Sample: identifier = "entity_" + sample.getIdentifier() + "_" + mc.property
     935                                                case Study: identifier = "entity_" + study.getIdentifier() + "_" + fieldName
     936                                                        break
     937                                                case Subject: identifier = "entity_" + subject.getIdentifier() + "_" + fieldName
     938                                                        break
     939                                                case SamplingEvent: identifier = "entity_" + samplingEvent.getIdentifier() + "_" + fieldName
     940                                                        break
     941                                                case Event: identifier = "entity_" + event.getIdentifier() + "_" + fieldName
     942                                                        break
     943                                                case Sample: identifier = "entity_" + sample.getIdentifier() + "_" + fieldName
    941944                                                        break
    942945                                                case Object:   // don't import
     
    972975                }
    973976        }
    974        
     977
    975978        /**
    976979         * Returns the preferred identifier field for a given entity or
  • trunk/grails-app/views/common/_topnav.gsp

    r1512 r1609  
    1414                <li><g:link controller="studyWizard" action="index" params="[jump:'create']">Create a new study</g:link></li>
    1515                <li><g:link controller="studyWizard" action="index" params="[jump:'edit']">Edit a study</g:link></li>
     16                <li><g:link controller="simpleWizard" action="index">Simple wizard</g:link></li>
    1617                <li><g:link controller="importer" action="index">Import study data</g:link></li>
    1718        <li><g:link controller="simpleQuery" action="index">Search study data</g:link></li>
  • trunk/grails-app/views/simpleWizard/simpleWizard/columns.gsp

    r1608 r1609  
    5959                                                                                                %>
    6060                                                                                                <g:each in="${allFields}" var="field">
    61                                                                                                         <%
    62                                                                                                                 def value = entityTemplates.key + "||" + field.name
    63                                                                                                                 def selected = ( value == selectedValue );
    64                                                                                                         %>
    65                                                                                                         <option value="${value}" <g:if test="${selected}">selected="selected"</g:if>>
    66                                                                                                                 ${field.name} <g:if test="${field.preferredIdentifier}">[identifier]</g:if>
     61                                                                                                        <g:if test="${field}">
     62                                                                                                                <%
     63                                                                                                                        def value = entityTemplates.key + "||" + field.name
     64                                                                                                                        def selected = ( value == selectedValue );
     65                                                                                                                %>
     66                                                                                                                <option value="${value}" <g:if test="${selected}">selected="selected"</g:if>>
     67                                                                                                                        ${field.name} <g:if test="${field.preferredIdentifier}">[identifier]</g:if>
     68                                                                                                                </option>
     69                                                                                                        </g:if>
    6770                                                                                                       
    6871                                                                                                </g:each>
  • trunk/grails-app/views/simpleWizard/simpleWizard/missingFields.gsp

    r1608 r1609  
    3131                                <g:if test="${imported.errors}">
    3232                                        <br /><br />The following errors occurred:<br />
    33                                         <g:each in="${imported.errors}" var="err">
     33                                        <g:each in="${imported.errors.unique()}" var="err">
    3434                                                ${err}<br />
    3535                                        </g:each>
  • trunk/grails-app/views/simpleWizard/simpleWizard/samples.gsp

    r1608 r1609  
    4848                                            </td>
    4949                                            <td>
    50                                                         <g:select rel="template" entity="${encodedEntity.Sample}" name="sample_template_id" optionKey="id" optionValue="name" from="${templates.Sample}"/>
     50                                                        <g:select rel="template" entity="${encodedEntity.Sample}" name="sample_template_id" optionKey="id" optionValue="name" from="${templates.Sample}" value="${sampleForm?.templateId?.Sample}"/>
    5151                                            </td>
    5252                                        </tr>
     
    5656                                            </td>
    5757                                            <td>
    58                                                         <g:select rel="template" entity="${encodedEntity.Subject}" name="subject_template_id" optionKey="id" optionValue="name" from="${templates.Subject}"/>
     58                                                        <g:select rel="template" entity="${encodedEntity.Subject}" name="subject_template_id" noSelection="${[null: '- no subject template -']}" optionKey="id" optionValue="name" from="${templates.Subject}"  value="${sampleForm?.templateId?.Subject}" />
    5959                                            </td>
    60                                         </tr>                                   
     60                                        </tr>
     61
     62                                        <tr>
     63                                            <td>
     64                                                <div id="datatemplate">Choose type of sampling event template:</div>
     65                                            </td>
     66                                            <td>
     67                                                        <g:select rel="template" entity="${encodedEntity.SamplingEvent}" name="samplingEvent_template_id" noSelection="${[null: '- no sampling event template -']}" optionKey="id" optionValue="name" from="${templates.SamplingEvent}"  value="${sampleForm?.templateId?.SamplingEvent}" />
     68                                            </td>
     69                                        </tr>           
    6170                                </table>       
    6271                        </div>
  • trunk/grails-app/views/study/list.gsp

    r1494 r1609  
    2020                                <thead>
    2121                                <tr>
    22                                         <th colspan="3"></th>
     22                                        <th colspan="4"></th>
    2323                                        <g:sortableColumn property="code" title="${message(code: 'study.code.label', default: 'Code')}"/>
    2424                                        <th>Title</th>
     
    3333
    3434                                                <td><input type="checkbox" name="id" value="${studyInstance.id}" id="${studyInstance.title}"></td>
    35                                                 <td><g:link action="show" id="${studyInstance?.id}"><img src='${fam.icon(name: 'application_form_magnify')}' border="0" alt="view study" /></g:link></td>
    36                                                 <td><g:if test="${studyInstance.canWrite(loggedInUser)}"><g:link class="edit" controller="studyWizard" params="[jump:'edit']" id="${studyInstance?.id}"><img src='${fam.icon(name: 'application_form_edit')}' border="0" alt="edit study" /></g:link></g:if><g:else><img src='${fam.icon(name: 'lock')}' border="0" alt="you have no write access to shis study" /></g:else> </td>
     35                                                <td><g:link action="show" title="View study" id="${studyInstance?.id}"><img src='${fam.icon(name: 'application_form_magnify')}' border="0" alt="view study" /></g:link></td>
     36                                                <td><g:if test="${studyInstance.canWrite(loggedInUser)}">
     37                                                        <g:link class="edit" title="Edit study using simple wizard" controller="simpleWizard" action="index" id="${studyInstance?.id}">
     38                                                                <img src='${fam.icon(name: 'pencil')}' border="0" alt="edit study" /></g:link>
     39                                                        </g:if><g:else><img src='${fam.icon(name: 'lock')}' border="0" alt="you have no write access to shis study" /></g:else>
     40                                                </td>
     41                                                <td><g:if test="${studyInstance.canWrite(loggedInUser)}">
     42                                                        <g:link class="edit" title="Edit study" controller="studyWizard" params="[jump:'edit']" id="${studyInstance?.id}">
     43                                                                <img src='${fam.icon(name: 'application_form_edit')}' border="0" alt="edit study" /></g:link>
     44                                                        </g:if><g:else><img src='${fam.icon(name: 'lock')}' border="0" alt="you have no write access to shis study" /></g:else>
     45                                                </td>
    3746                                                <td>${fieldValue(bean: studyInstance, field: "code")}</td>
    3847                                                <td>
  • trunk/grails-app/views/study/show.gsp

    r1461 r1609  
    215215                                <g:hiddenField name="id" value="${studyInstance?.id}"/>
    216216                                <g:if test="${studyInstance.canWrite(loggedInUser)}">
     217                                        <span class="button"><g:link class="edit" controller="simpleWizard" action="index" id="${studyInstance?.id}">Simple edit</g:link></span>
    217218                                        <span class="button"><g:link class="edit" controller="studyWizard" params="[jump:'edit']" id="${studyInstance?.id}">${message(code: 'default.button.edit.label', default: 'Edit')}</g:link></span>
    218219                                </g:if>
Note: See TracChangeset for help on using the changeset viewer.