Changeset 497


Ignore:
Timestamp:
May 28, 2010, 4:19:06 PM (7 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 edited

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    }
Note: See TracChangeset for help on using the changeset viewer.