Changeset 497

Show
Ignore:
Timestamp:
28-05-10 16:19:06 (4 years ago)
Author:
roberth
Message:

Implemented RELTIME parsing and showing in the wizard.
Also made TEXT templatefields to show a textarea

Location:
trunk
Files:
2 added
8 modified

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/conf/BootStrap.groovy

    r493 r497  
    407407 
    408408                                def evLF = new Event( 
    409                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    410                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     409                                        startTime: 3600, 
     410                                        endTime: 3600 +7 * 24 * 3600, 
    411411                                        template: dietTreatmentTemplate 
    412412                                ) 
     
    415415 
    416416                                def evHF = new Event( 
    417                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    418                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     417                                        startTime: 3600, 
     418                                        endTime: 3600 +7 * 24 * 3600, 
    419419                                        template: dietTreatmentTemplate 
    420420                                ) 
     
    423423 
    424424                                def evBV = new Event( 
    425                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    426                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     425                                        startTime: 3600, 
     426                                        endTime: 3600 +7 * 24 * 3600, 
    427427                                        template: boostTreatmentTemplate 
    428428                                ) 
     
    431431 
    432432                                def evBL = new Event( 
    433                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    434                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     433                                        startTime: 3600, 
     434                                        endTime: 3600 +7 * 24 * 3600, 
    435435                                        template: boostTreatmentTemplate 
    436436                                ) 
     
    439439 
    440440                                def evLF4 = new Event( 
    441                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    442                                         endTime: Date.parse('yyyy-MM-dd','2008-02-04'), 
     441                                        startTime: 3600, 
     442                                        endTime: 3600 + 4 * 7 * 24 * 3600, 
    443443                                        template: dietTreatmentTemplate 
    444444                                ) 
     
    447447 
    448448                                def evHF4 = new Event( 
    449                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    450                                         endTime: Date.parse('yyyy-MM-dd','2008-02-04'), 
     449                                        startTime: 3600, 
     450                                        endTime: 3600 + 4 * 7 * 24 * 3600, 
    451451                                        template: dietTreatmentTemplate 
    452452                                ) 
     
    455455 
    456456                                def evBV4 = new Event( 
    457                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    458                                         endTime: Date.parse('yyyy-MM-dd','2008-02-04'), 
     457                                        startTime: 3600, 
     458                                        endTime: 3600 + 4 * 7 * 24 * 3600, 
    459459                                        template: boostTreatmentTemplate 
    460460                                ) 
     
    463463 
    464464                                def evBL4 = new Event( 
    465                                         startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    466                                         endTime: Date.parse('yyyy-MM-dd','2008-02-04'), 
     465                                        startTime: 3600, 
     466                                        endTime: 3600 + 4 * 7 * 24 * 3600, 
    467467                                        template: boostTreatmentTemplate 
    468468                                ) 
     
    471471 
    472472                                def evS = new SamplingEvent( 
    473                                         startTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    474                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     473                                        startTime: 3600 +7 * 24 * 3600, 
     474                                        endTime: 3600 +7 * 24 * 3600, 
    475475                                        template: liverSamplingEventTemplate) 
    476476                                .setFieldValue('Sample weight',5F) 
     
    478478 
    479479                                def evS4 = new SamplingEvent( 
    480                                         startTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    481                                         endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
     480                                        startTime: 3600 +7 * 24 * 3600, 
     481                                        endTime: 3600 +7 * 24 * 3600, 
    482482                                        template: liverSamplingEventTemplate) 
    483483                                .setFieldValue('Sample weight',5F) 
     
    613613 
    614614                                def fastingEvent = new Event( 
    615                                         startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-14 22:00'), 
    616                                         endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'), 
     615                                        startTime: 3 * 24 * 3600 + 22 * 3600, 
     616                                        endTime: 3 * 24 * 3600 + 30 * 3600, 
    617617                                        template: fastingTreatment) 
    618618                                .setFieldValue('Fasting period','8h'); 
     
    620620 
    621621                                def bloodSamplingEvent = new SamplingEvent( 
    622                                         startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'), 
    623                                         endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'), 
     622                                        startTime: 3 * 24 * 3600 + 30 * 3600, 
     623                                        endTime: 3 * 24 * 3600 + 30 * 3600, 
    624624                                        template: bloodSamplingEventTemplate) 
    625625                                .setFieldValue('Sample volume',4.5F); 
  • trunk/grails-app/controllers/dbnp/studycapturing/StudyController.groovy

    r468 r497  
    7373    def events = { 
    7474        def eventGroup = EventGroup.get(params.id) 
    75         def startDate  = params.startDate 
    7675 
     76        // This parameter should give the startdate of the study in milliseconds 
     77        // since 1-1-1970 
     78        long startDate  = Long.parseLong( params.startDate ) 
     79         
    7780        if (!eventGroup) { 
    7881            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventgroup.label', default: 'Eventgroup'), params.id])}" 
     
    104107                } 
    105108 
    106                 json.events << [ 
    107                     'start':    event.startTime, 
    108                     'end':      event.endTime, 
     109                 json.events << [ 
     110                    'start':    new Date( startDate + event.startTime * 1000 ), 
     111                    'end':      new Date( startDate + event.endTime * 1000 ), 
    109112                    'durationEvent': !event.isSamplingEvent(), 
    110113                    'title': event.template.name + " (" + parameters.join( ', ' ) + ")", 
  • trunk/grails-app/domain/dbnp/studycapturing/Event.groovy

    r496 r497  
    1414 */ 
    1515class Event extends TemplateEntity implements Serializable { 
    16         Date startTime 
    17         Date endTime 
     16        long startTime 
     17        long endTime 
    1818 
    1919        /** 
     
    4848                        new TemplateField( 
    4949                                name: 'startTime', 
    50                                 type: TemplateFieldType.DATE), 
     50                                type: TemplateFieldType.RELTIME), 
    5151                        new TemplateField( 
    5252                                name: 'endTime', 
    53                                 type: TemplateFieldType.DATE) 
     53                                type: TemplateFieldType.RELTIME) 
    5454                ] 
    5555 
    56         /** 
    57          * get the event duration 
    58          * @return Duration 
    59          */ 
    60         static def getDuration(date1, date2) { 
    61                 def timeMillis = (date2.getTime() - date1.getTime()).abs() 
    62                 def days = (timeMillis / (1000 * 60 * 60 * 24)).toInteger() 
    63                 def hours = (timeMillis / (1000 * 60 * 60)).toInteger() 
    64                 def minutes = (timeMillis / (1000 * 60)).toInteger() 
    65                 def seconds = (timeMillis / 1000).toInteger() 
    66                 def millis = (timeMillis % 1000).toInteger() 
    67  
    68                 return new Duration(days, hours, minutes, seconds, millis) 
    69         } 
    70  
    7156        def getDuration() { 
    72                 return getDuration(startTime, endTime) 
     57                return new RelTime(startTime, endTime); 
    7358        } 
    7459 
     
    7762         * @return String 
    7863         */ 
    79         static def getPrettyDuration(duration) { 
    80                 def handleNumerus = {number, string -> 
    81                         return number.toString() + (number == 1 ? string : string + 's') 
    82                 } 
    83                 if (duration.getYears() > 0) return handleNumerus(duration.getYears(), " year") 
    84                 if (duration.getMonths() > 0) return handleNumerus(duration.getMonths(), " month") 
    85                 if (duration.getDays() > 0) return handleNumerus(duration.getDays(), " day") 
    86                 if (duration.getHours() > 0) return handleNumerus(duration.getHours(), " hour") 
    87                 if (duration.getMinutes() > 0) return handleNumerus(duration.getMinutes(), " minute") 
    88                 return handleNumerus(duration.getSeconds(), " second") 
     64        static def getPrettyDuration(RelTime duration) { 
     65            return duration.toPrettyRoundedString(); 
    8966        } 
    9067 
    9168        def getPrettyDuration() { 
    92                 getPrettyDuration(getDuration()) 
    93         } 
    94  
    95         static def getPrettyDuration(date1, date2) { 
    96                 return getPrettyDuration(getDuration(date1, date2)) 
     69            getPrettyDuration(getDuration()) 
    9770        } 
    9871 
    9972        def getDurationString() { 
    100                 def d = getDuration() 
    101                 return "${d.days} days, ${d.hours} hrs, ${d.minutes} min, ${d.seconds} sec." 
     73            def d = getDuration() 
     74            return getDuration().toPrettyString(); 
    10275        } 
    10376 
    10477        def getShortDuration() { 
    105                 def d = getDuration() 
    106                 def days = d.days 
    107                 def hours = d.hours - (24 * days) 
    108                 def minutes = d.minutes - (24 * 60 * days) - (60 * hours) 
    109                 return "${days}d ${hours}:${minutes}" 
     78            def d = getDuration() 
     79            return getDuration().toString(); 
    11080        } 
    11181 
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r496 r497  
    378378                // Magic setter for relative times: handle string values for relTime fields 
    379379                // 
    380                 // The relative time may be set as a string, using the following format 
    381                 // 
    382                 //    #w #d #h #m #s 
    383                 // 
    384                 // Where w = weeks, d = days, h = hours, m = minutes, s = seconds 
    385                 // 
    386                 // The spaces between the values are optional. Every timespan 
    387                 // (w, d, h, m, s) must appear at most once. You can also omit 
    388                 // timespans if needed or use a different order. 
    389                 // Other characters are disregarded, allthough results may not 
    390                 // always be as expected. 
    391                 //   
    392                 // If an incorrect format is used, which can't be parsed 
    393                 // an IllegalArgumentException is thrown. 
    394                 // 
    395                 // An empty span is treated as zero seconds. 
    396                 // 
    397                 // Examples: 
    398                 // --------- 
    399                 //    5d 3h 20m     // 5 days, 3 hours and 20 minutes 
    400                 //    6h 2d         // 2 days, 6 hours 
    401                 //    10m 200s      // 13 minutes, 20 seconds (200s == 3m + 20s) 
    402                 //    5w4h15m       // 5 weeks, 4 hours, 15 minutes 
    403                 // 
    404                 //    16x14w10d     // Incorrect. 16x is disregarded, so the 
    405                 //                  // result is 15 weeks, 3 days 
    406                 //    13days        // Incorrect: days should be d, but this is 
    407                 //                  // parsed as 13d, 0 seconds 
    408                 // 
    409                 if (field.type == TemplateFieldType.RELTIME && value.class == String) { 
    410                         // A string was given, attempt to transform it into a timespan 
    411  
    412                         // An empty string should be parsed as 0 
    413                         if( value.trim() == "" ) { 
    414                             value = 0; 
    415                         } else { 
    416                             // Find all parts that contain numbers with 
    417                             // a character w, d, h, m or s after it 
    418                             def periodMatch = value =~ /([0-9]+)([wdhms])/ 
    419                             if (periodMatch.size() > 0 ) { 
    420                                     def seconds = 0L; 
    421  
    422                                     // Now check if every part contains data for 
    423                                     // the time interval 
    424                                     periodMatch.each { 
    425                                         def partValue 
    426  
    427                                         println it 
    428  
    429                                         if( it[1].isLong() ) { 
    430                                             partValue = Long.parseLong( it[1] ); 
    431                                         } else { 
    432                                             partValue = 0; 
    433                                         } 
    434  
    435                                         switch( it[ 2 ] ) { 
    436                                             case 'w': 
    437                                                 seconds += 7L * 24 * 60 * 60 * partValue; 
    438                                                 break; 
    439                                             case 'd': 
    440                                                 seconds += 24L * 60 * 60 * partValue; 
    441                                                 break; 
    442                                             case 'h': 
    443                                                 seconds += 60L * 60 * partValue; 
    444                                                 break; 
    445                                             case 'm': 
    446                                                 seconds += 60L * partValue; 
    447                                                 break; 
    448                                             case 's': 
    449                                                 seconds += partValue; 
    450                                                 break; 
    451                                             default: 
    452                                                 adf.error.warn( 'Parsing relative time: ' + it[0] + it[1] + ' is not understood and disregarded' ); 
    453                                                 break; 
    454                                         } 
    455                                     } 
    456  
    457                                     // Continue with the computed value 
    458                                     value = seconds; 
    459                             } else { 
    460                                 throw new IllegalArgumentException( "String " + value + " cannot be parsed as a relative time. Use format #w #d #h #m #s." ); 
    461                             } 
    462                         } 
     380                if (field.type == TemplateFieldType.RELTIME && value != null && value.class == String) { 
     381                    // A string was given, attempt to transform it into a timespan 
     382                    value = RelTime.parseRelTime( value ).getValue(); 
    463383                } 
    464384 
     
    487407                                println ".unsetting [" + ((super) ? super.class : '??') + "] domain field: [" + fieldName + "]" 
    488408 
    489                                 // remove value 
    490                                 this[field.name] = null 
     409                                // remove value. For numbers, this is done by setting 
     410                                // the value to 0, otherwise, setting it to NULL 
     411                                switch( field.type.toString() ) { 
     412                                    case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME']: 
     413                                        this[field.name] = 0; 
     414                                        break; 
     415                                    default: 
     416                                        this[field.name] = null 
     417                                } 
    491418                        } 
    492419                } else { 
  • trunk/grails-app/taglib/dbnp/studycapturing/WizardTagLib.groovy

    r494 r497  
    351351        } 
    352352 
     353        /** 
     354         * render a textAreaElement 
     355         * @param Map attrs 
     356         * @param Closure body  (help text) 
     357         */ 
     358        def textAreaElement = {attrs, body -> 
     359                // set default size, or scale to max length if it is less than the default size 
     360 
     361                // render template element 
     362                baseElement.call( 
     363                        'textArea', 
     364                        attrs, 
     365                        body 
     366                ) 
     367        } 
     368 
     369 
    353370        /** 
    354371         * render a select form element 
     
    804821 
    805822                                switch (it.type.toString()) { 
    806                                         case ['STRING', 'TEXT', 'INTEGER', 'FLOAT', 'DOUBLE']: 
     823                                        case ['STRING', 'INTEGER', 'FLOAT', 'DOUBLE']: 
    807824                                                inputElement = (renderType == 'element') ? 'textFieldElement' : 'textField' 
     825                                                out << "$inputElement"( 
     826                                                        description: ucName, 
     827                                                        name: prependName + it.escapedName(), 
     828                                                        value: fieldValue 
     829                                                ){helpText} 
     830                                                break 
     831                                        case 'TEXT': 
     832                                                inputElement = (renderType == 'element') ? 'textAreaElement' : 'textField' 
    808833                                                out << "$inputElement"( 
    809834                                                        description: ucName, 
     
    890915                                                ){helpText} 
    891916                                                break 
     917                                        case ['RELTIME']: 
     918                                                inputElement = (renderType == 'element') ? 'textFieldElement' : 'textField' 
     919                                                out << "$inputElement"( 
     920                                                        description: ucName, 
     921                                                        name: prependName + it.escapedName(), 
     922                                                        value: new RelTime( fieldValue ).toString() 
     923                                                ){helpText} 
     924                                                break 
    892925                                        default: 
    893926                                                // unsupported field type 
  • trunk/grails-app/views/query/selectsample.gsp

    r359 r497  
    6868                 <td> ${sample.material}</td> 
    6969 
    70                  <td> ${event.getPrettyDuration( studyIns.startDate, event.startTime)} </td> 
     70                 <td> ${event.getPrettyDuration(event.startTime)} </td> 
    7171 
    7272                 <td> 
  • trunk/grails-app/views/study/show.gsp

    r467 r497  
    11 
    22<%@ page import="dbnp.studycapturing.Study" %> 
     3<%@ page import="dbnp.studycapturing.RelTime" %> 
    34<html> 
    45  <head> 
     
    9495 
    9596                // Load events for this eventsource (using jquery) 
    96                 var event_url = '${createLink(controller:'study', action:'events', id:eventGroup.id, params: [startDate: study.startDate])}'; 
     97                var event_url = '${createLink(controller:'study', action:'events', id:eventGroup.id, params: [startDate: study.startDate.getTime() ])}'; 
    9798                $.getJSON(event_url, $.callback( _loadJSONEvents, [0, ${bandNr}, eventSources[${bandNr}], overviewEventSource, event_url] ) ); 
    9899 
     
    389390                    sortedEvents = events.sort( { a, b -> 
    390391                          a.startTime == b.startTime ? 
    391                             a.getDuration().toMilliseconds() <=> b.getDuration().toMilliseconds() : 
     392                            a.getDuration().getValue() <=> b.getDuration().getValue() : 
    392393                            a.startTime <=> b.startTime 
    393394                      } as Comparator ) 
     
    401402                        </td> 
    402403                      </g:if> 
    403                       <td>${event.getPrettyDuration(studyInstance.startDate,event.startTime)}</td> 
     404                      <td>${new RelTime(event.startTime).toPrettyString()}</td> 
    404405                      <td>${event.getPrettyDuration()}</td> 
    405406                      <td>${event.template.name}</td> 
  • trunk/test/unit/dbnp/studycapturing/TemplateFieldTests.groovy

    r496 r497  
    2626        this.testEvent = new Event( 
    2727                template: testTemplate, 
    28                 startTime: Date.parse('yyyy-MM-dd','2008-01-02'), 
    29                 endTime: Date.parse('yyyy-MM-dd','2008-01-05') 
     28                startTime: 3600, 
     29                endTime: 7200 
    3030        ) 
    3131    }