Changeset 705


Ignore:
Timestamp:
2008-10-17 15:17:11 (5 years ago)
Author:
paul
Message:

Time & date time types
Plus a little documentation

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/kauri-forms/kauri-forms-framework/src/main/kauri/js/date.js

    r694 r705  
    2121 
    2222    // adding the new types to the registries... 
    23     formatters.put("pattern-date" , { 
    24         // default to the ISO8601 datetime format 
    25         pattern : $.datepicker.ISO_8601, 
    26          
    27         format : function( val) { 
    28             if (val == undefined) 
    29                 return ""; 
    30             if (val.constructor != Date) 
    31                 this.fail("Not a Date: {0}.", [val]); 
    32  
    33             return $.datepicker.formatDate(this.pattern, val);                 
    34         }, 
    35          
    36         parse : function(valstr) {       
    37             if (typeof valstr == 'string') {  
    38                 valstr = $.trim(valstr);  
    39                 if (valstr.length == 0)  
    40                     return undefined;  
    41                      
    42                 try { 
    43                     return $.datepicker.parseDate(this.pattern, valstr);                  
    44                 } catch (e) { 
    45                     // do nothing yet, we'll fail later 
    46                 } 
    47             }    
    48             this.fail( "Could not parse the date : " + valstr );          
    49         } 
    50     }); 
    51      
    52     formatters.put("pattern-date-range", { 
    53         pattern : $.datepicker.ISO_8601, 
    54         rangeSeparator : " - ", 
    55         format : function (val) { 
    56             if (val == undefined) 
    57                 return ""; 
    58             if (val.length != 2) 
    59                 this.fail("Not a Date Range: {0}.", [val]); 
     23    formatters.putAll( { 
     24        "pattern-date" : { 
     25            // default to the ISO8601 datetime format 
     26            pattern : $.datepicker.ISO_8601, 
    6027             
    61             var formattedRange = [ 
    62                 $.datepicker.formatDate(this.pattern, val[0]), 
    63                 $.datepicker.formatDate(this.pattern, val[1]) 
    64             ]     
     28            format : function( val) { 
     29                if (val == undefined) 
     30                    return ""; 
     31                if (val.constructor != Date) 
     32                    this.fail("Not a Date: {0}.", [val]); 
     33     
     34                return $.datepicker.formatDate(this.pattern, val);                 
     35            }, 
    6536             
    66             return formattedRange.join(this.rangeSeparator);   
    67         }, 
    68         parse : function(valstr) {      
    69             var rangeArr;  
    70             if (typeof valstr == 'string') {  
    71                 valstr = $.trim(valstr);  
    72                 if (valstr.length == 0)  
    73                     return undefined; 
    74                       
    75                 rangeArr = valstr.split(this.rangeSeparator); 
    76              } else if (valstr.constructor == Array) { 
    77                 rangeArr = valstr 
    78              }     
    79               
    80              if (rangeArr != null) { 
    81                 try { 
    82                      
    83                     if (rangeArr.length == 2) { 
    84                         return  [ 
    85                             $.datepicker.parseDate(this.pattern, $.trim(rangeArr[0])), 
    86                             $.datepicker.parseDate(this.pattern, $.trim(rangeArr[1]))   
    87                         ]; 
    88                     } 
    89                 } catch (e) { 
    90                     // do nothing yet, we'll fail later 
    91                 } 
    92             }    
    93             this.fail( "Could not parse the date : " + valstr );          
    94         } 
    95     }); 
    96  
    97     formatters.put("short-date", { 
    98         base :"pattern-date", 
    99         pattern :"dd/mm/yy" 
    100     }); 
    101     formatters.put("short-date-range", { 
    102         base :"pattern-date-range", 
    103         pattern :"dd/mm/yy" 
    104     }); 
    105     /* TODO jquery datetime formatting 
    106     formatters.put("short-datetime", { 
    107         base :"pattern-date", 
    108         pattern :"dd/MM/yyyy HH:mm:ss" 
    109     }); 
    110     formatters.put("short-time", { 
    111         base :"pattern-date", 
    112         pattern :"HH:mm:ss" 
    113     }); 
    114     */ 
    115     formatters.put("wire-date", { 
    116         base :"pattern-date", 
    117         pattern : $.datepicker.ISO_8601 
    118     }); 
    119     formatters.put("wire-date-range", { 
    120         base :"pattern-date-range", 
    121         pattern : $.datepicker.ISO_8601 
    122     }); 
    123      
    124      
    125     /* 
    126     formatters.put("wire-datetime", { 
    127         base :"pattern-date", 
    128         pattern :"yyyy-MM-ddTHH:mm:ssZ" 
    129     }); 
    130     formatters.put("wire-time", { 
    131         base :"pattern-date", 
    132         pattern :"HH:mm:ssZ" 
    133     }); 
    134     */ 
     37            parse : function(valstr) {       
     38                if (typeof valstr == 'string') {  
     39                    valstr = $.trim(valstr);  
     40                    if (valstr.length == 0)  
     41                        return undefined;  
     42                         
     43                    try { 
     44                        return $.datepicker.parseDate(this.pattern, valstr);                  
     45                    } catch (e) { 
     46                        // do nothing yet, we'll fail later 
     47                    } 
     48                }    
     49                this.fail( "Could not parse the date : " + valstr );          
     50            } 
     51        }, 
     52        "pattern-date-range" : { 
     53            pattern : $.datepicker.ISO_8601, 
     54            rangeSeparator : " - ", 
     55            format : function (val) { 
     56                if (val == undefined) 
     57                    return ""; 
     58                if (val.length != 2) 
     59                    this.fail("Not a Date Range: {0}.", [val]); 
     60                 
     61                var formattedRange = [ 
     62                    $.datepicker.formatDate(this.pattern, val[0]), 
     63                    $.datepicker.formatDate(this.pattern, val[1]) 
     64                ]     
     65                 
     66                return formattedRange.join(this.rangeSeparator);   
     67            }, 
     68            parse : function(valstr) {      
     69                var rangeArr;  
     70                if (typeof valstr == 'string') {  
     71                    valstr = $.trim(valstr);  
     72                    if (valstr.length == 0)  
     73                        return undefined; 
     74                          
     75                    rangeArr = valstr.split(this.rangeSeparator); 
     76                 } else if (valstr.constructor == Array) { 
     77                    rangeArr = valstr 
     78                 }     
     79                  
     80                 if (rangeArr != null) { 
     81                    try { 
     82                         
     83                        if (rangeArr.length == 2) { 
     84                            return  [ 
     85                                $.datepicker.parseDate(this.pattern, $.trim(rangeArr[0])), 
     86                                $.datepicker.parseDate(this.pattern, $.trim(rangeArr[1]))   
     87                            ]; 
     88                        } 
     89                    } catch (e) { 
     90                        // do nothing yet, we'll fail later 
     91                    } 
     92                }    
     93                this.fail( "Could not parse the date : " + valstr );          
     94            } 
     95        }, 
     96        "time" : { 
     97            prependZero : function (val) { 
     98                    var s = ""; 
     99                    s += val; 
     100                    if (s.length == 1) s = "0" + s; 
     101                    return s; 
     102            }, 
     103            format : function (val) { 
     104                if (val == undefined) 
     105                    return ""; 
     106                if (val.constructor != Date) 
     107                    this.fail("Not a Date: {0}.", [val]); 
     108                     
     109                var valstr = (this.prependZero(val.getHours()) + ":" + this.prependZero(val.getMinutes()) + ":" + this.prependZero(val.getSeconds())); 
     110                return valstr 
     111            }, 
     112            parse : function (valstr) { 
     113                if (typeof valstr == 'string') {  
     114                    valstr = $.trim(valstr);  
     115                    if (valstr.length == 0)  
     116                        return undefined;  
     117                     
     118                    var checkNumber = function (numStr, max) { 
     119                        var num = new Number(numStr); 
     120                        if (num != Number.NaN && num <= max) 
     121                            return num  
     122                        else  
     123                            return null;     
     124                    } 
     125                         
     126                    try {                         
     127                        var valArr = valstr.split(":"); 
     128                         
     129                        var hour = 0,minute = 0,second = 0; 
     130                        if (valArr[0]) { 
     131                            hour = checkNumber(valArr[0],24);                             
     132                        }  
     133                        if (valArr[1]) { 
     134                            minute = checkNumber(valArr[1], 60); 
     135                        } 
     136                        if (valArr[2]) { 
     137                            second =  checkNumber(valArr[2], 60); 
     138                        } 
     139                         
     140                        if (hour != null && minute != null && second != null) { 
     141                            return new Date(0,0,0, hour, minute, second, 0); 
     142                        }s                 
     143                    } catch (e) { 
     144                        // do nothing yet, we'll fail later 
     145                    } 
     146                }    
     147                this.fail( "Could not parse the date : " + valstr );   
     148            } 
     149        }, 
     150        "short-date" : { 
     151            base :"pattern-date", 
     152            pattern :"dd/mm/yy" 
     153        }, 
     154        "short-date-range" : { 
     155            base :"pattern-date-range", 
     156            pattern :"dd/mm/yy" 
     157        }, 
     158        "wire-date" : { 
     159            base :"pattern-date", 
     160            pattern : $.datepicker.ISO_8601 
     161        }, 
     162            "wire-date-range" : { 
     163            base :"pattern-date-range", 
     164            pattern : $.datepicker.ISO_8601 
     165        } 
     166    }); 
    135167     
    136168    // validators 
    … …  
    212244 
    213245    fieldTypes.putAll( { 
    214  
    215246        "date" : {  
    216247            control: 'date-control', 
    … …  
    231262            'user-format' :"short-date-range", 
    232263            'wire-format' :"wire-date-range" 
    233         } 
    234          
    235 /* 
    236         "datetime" : {  
    237             '@validators' : { 
    238                 "isDate" : {} 
    239             }, 
    240             'user-format' :"short-datetime", 
    241             'wire-format' :"wire-datetime" 
    242         }, 
    243  
     264        }, 
    244265        "time" : { 
    245             '@validators' : { 
    246                 "isDate" : {} 
    247             }, 
    248             'user-format' :"short-time", 
    249             'wire-format' :"wire-time" 
    250         } 
    251         */ 
    252     }); 
     266            'user-format' : "time", 
     267            'wire-format' : "time" 
     268        } 
     269    }); 
     270    fieldTypes.put("datetime", { 
     271            base : "composite", 
     272            members : { 
     273                "date" : { type : "date"}, 
     274                "time" : { type : "time"} 
     275            }, 
     276            control : "datetime-control"  
     277        }); 
    253278 
    254279    $.inherit(DateControl, kf.Control); 
    … …  
    322347    */ 
    323348    controlTypes.putAll( { 
    324         "date-control" :DateControl 
     349        "date-control" :DateControl, 
     350        "datetime-control" :  { 
     351            base : "composite-control", 
     352            elements : {             
     353                input : { create : "<div/>" }, 
     354                label : { create : "<span/>" }, 
     355                container : { create : "<div/>" }, 
     356                layout : { create : "<span kauri-rev='item'><input kauri-rev='input'/><span kauri-rev='messages'/></span>" } 
     357            }, 
     358            setWireValue : function (value) { 
     359                var valArr = value.split("T"); 
     360                var newVal = {date : valArr[0], time : valArr[1]} 
     361                return this.setValueLoop("setWireValue", newVal); 
     362            }, 
     363            getWireValue : function() { 
     364                // concat the date with the time 
     365                var value = this.getValueLoop("getWireValue"); 
     366                return value.date + "T" + value.time; 
     367            } 
     368        } 
    325369        /* 
    326370        "datetime-control" :DateTimeControl, 
    … …  
    328372        */ 
    329373    }); 
    330      
    331      
    332      
    333  
    334374})(jQuery); 

  • trunk/modules/kauri-forms/kauri-forms-framework/src/main/kauri/js/field.js

    r647 r705  
    311311 
    312312        for ( var ref in subtypes) { 
    313             var type = subtypes[ref].type; 
    314             subtypes[ref] = FieldType.buildType(builder, type); 
     313            // only build field types if they haven't been built already 
     314            if (subtypes[ref].format == null) { 
     315                var type = subtypes[ref].type; 
     316                subtypes[ref] = FieldType.buildType(builder, type); 
     317            } 
    315318        } 
    316319    } 

  • trunk/modules/kauri-forms/kauri-forms-framework/src/main/kauri/js/location.js

    r701 r705  
    66 
    77    if (!$) 
    8         throw "Kauri Forms Advanced-Controls requires jQuery"; 
     8        throw "Kauri Forms Location module requires jQuery"; 
    99    if (!$.org.kauriproject.forms) 
    10         throw "Kauri Forms Advanced-Controls requires the kauri-form namespace"; 
     10        throw "Kauri Forms Location module requires the kauri-form namespace"; 
    1111     
    1212    var kp = $.org.kauriproject; 
    … …  
    2525     
    2626    $.inherit(GMapControl, kf.AbstractContainerControl); 
     27     
     28    /** 
     29    * @class Uses a google map as a control for choosing a location 
     30    * @param {id}  
     31    *            identification for this control 
     32    * @param {Form} 
     33    *            form form where this control resides in 
     34    * @param {FieldType} 
     35    *            type supporting FieldType for this control 
     36    * @constructor 
     37    */ 
    2738    function GMapControl ( id, form, conf) { 
    2839        this['<super.init>'](id, form, conf); 
    2940    } 
    3041     
    31     // google maps api key for http://localhost:8888/ 
     42    /** 
     43    * The google maps api key. Defaults to a key for http://localhost:8888/ 
     44    */ 
    3245    GMapControl.prototype.apiKey = "ABQIAAAAOLLfFZQRGe8Hwl8R-4_7ABTb-vLQlFZmc2N8bgWI8YDPp5FEVBRSxdJTJfWoHiTs2nyCjV6ZpIuHvA";  
    3346     

  • trunk/modules/kauri-forms/kauri-forms-framework/src/test/js/test-date.js

    r694 r705  
    5454    assertFail(f, "parse", "29/08/2008 26:15:20"); 
    5555}); 
    56  
    57 test("wire-time formatter test", function() { 
    58     var f = getFormatter("wire-time");     
    59      
    60     expect(6); 
    61      
    62     var d = Date.today().add({hours:8,minutes:50,seconds:20}); 
    63      
    64     // check if the formatted exists 
    65     ok(f != null, "There should be a wire-date"); 
    66      
    67     //test formatting 
    68     assertFail(f, "format", "This is not a date"); 
    69     assertConvert(f, "format", d, "08:50:20Z"); 
    70      
    71     //test parsing 
    72     // TODO have a look at datejs to see why the iso8601 time format isn't being parsed in all it's glory     
    73     //assertConvert(f, "parse", "08:50:20Z", d); 
    74     assertConvert(f, "parse", "8:50:20am", d); 
    75     assertConvert(f, "parse", "8:50:20", d);       
    76     assertFail(f, "parse", "8:65:20");   
    77 }); 
    7856*/ 
     57test("time formatter test", function() { 
     58    var f = getFormatter("time");     
     59     
     60    expect(7); 
     61     
     62    var d = new Date(0, 0, 0, 14, 3, 33, 0) 
     63     
     64    // check if the formatted exists 
     65    ok(f != null, "There should be a time formatter"); 
     66     
     67    //test formatting 
     68    assertFail(f, "format", "This is not a date"); 
     69    assertConvert(f, "format", d, "14:03:33"); 
     70     
     71    //test parsing 
     72    var parsedTime = f.parse("14:3:33"); 
     73    ok (d.getHours() == parsedTime.getHours() && d.getMinutes() == parsedTime.getMinutes() && d.getSeconds() == parsedTime.getSeconds(), "The parsed date doesn't match the test date"); 
     74    parsedTime = f.parse("14:3"); 
     75    ok (d.getHours() == parsedTime.getHours() && d.getMinutes() == parsedTime.getMinutes() && 0 == parsedTime.getSeconds(), "The parsed date doesn't match the test date"); 
     76    parsedTime = f.parse("14"); 
     77    ok (d.getHours() == parsedTime.getHours() && 0 == parsedTime.getMinutes() && 0 == parsedTime.getSeconds(), "The parsed date doesn't match the test date");      
     78    assertFail(f, "parse", "abb");   
     79}); 
     80 
    7981test ("pattern-date formatter test", function() { 
    8082    var f = getFormatter("pattern-date", {pattern : "dd | mm | yy"}); 

  • trunk/samples/kauri-forms-sample/src/main/kauri/router.groovy

    r702 r705  
    3535                def rand = new Random(); 
    3636                def dateFormat = new SimpleDateFormat("yyyy-MM-dd"); 
     37                def dateTimeFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss"); 
    3738                def contactTypes = [  
    3839                    [ 'caseName' : "phone", 'value' : "'222-2222'" ], 
    … …  
    5960                        ", friendscount: "+ (11 - i) +  
    6061                        ", pi: " + String.valueOf(Math.PI).substring(0, i+2) +   
    61                         ", birthdate: '" + dateFormat.format(bday.getTime()) + "'" + 
     62                        ", birthdate: '" + dateTimeFormat.format(bday.getTime()) + "'" + 
    6263                        ", holiday: ['" + dateFormat.format(holidayStart.getTime()) + "', '" + dateFormat.format(holidayEnd.getTime()) + "']" + 
    6364                        ", description : '" + description + "'" +  

  • trunk/samples/kauri-forms-sample/src/main/kauri/templates/data/sample-form-config.xml

    r702 r705  
    3535        }, 
    3636        'birthdate' : { 
    37           type: ['date', { 
    38           control : ['date-control', {label : 'When is your next birthday?'}] 
     37          type: ['datetime', { 
     38            control : ['datetime-control', {label : 'When is your next birthday?'}] 
    3939          }] 
    4040        }, 
    4141        'holiday' : { 
    4242          type: ['date-range', { 
    43           control : ['date-control', {label : 'When and how long is your next holiday?', isRange : true}] 
     43            control : ['date-control', {label : 'When and how long is your next holiday?', isRange : true}] 
    4444          }] 
    4545        },         
Note: See TracChangeset for help on using the changeset viewer.