Ignore:
Timestamp:
May 28, 2010, 4:19:06 PM (10 years ago)
Author:
roberth
Message:

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

Location:
trunk/grails-app/domain/dbnp/studycapturing
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • 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 {
Note: See TracChangeset for help on using the changeset viewer.