commit 3f02a7a7a11e93c4c1fb139c9546439ddaf14e08 · ryan.freumh.org/caledonia

+1 -1

bin/add_cmd.ml

···

       47
       47
        
           Term.(

     

       48
       48
        
             const run $ required_summary_arg $ start_date_arg $ start_time_arg

     

       49
       49
        
             $ end_date_arg $ end_time_arg $ location_arg $ description_arg $ recur_arg

     

       50
       50
       -
             $ calendar_name_arg $ timezone_arg $ end_time_arg)

     

       50
       50
       +
             $ calendar_name_arg $ timezone_arg $ end_timezone_arg)

     

       51
       51
        
         in

     

       52
       52
        
         let doc = "Add a new calendar event" in

     

       53
       53
        
         let man =

+27

bin/event_args.ml

···

       104
       104
        
       

     

       105
       105
        
       let parse_start ~start_date ~start_time ~timezone =

     

       106
       106
        
         let ( let* ) = Result.bind in

     

       107
       107
       +
         let* _ =

     

       108
       108
       +
           match timezone with

     

       109
       109
       +
           | None -> Ok ()

     

       110
       110
       +
           | Some tzid -> (

     

       111
       111
       +
               match Timedesc.Time_zone.make tzid with

     

       112
       112
       +
               | Some _ -> Ok ()

     

       113
       113
       +
               | None ->

     

       114
       114
       +
                   Error (`Msg (Printf.sprintf "Warning: Unknown timezone %s" tzid)))

     

       115
       115
       +
         in

     

       107
       116
        
         match start_date with

     

       108
       117
        
         | None ->

     

       109
       118
        
             let* _ =

     
···

       165
       174
        
       

     

       166
       175
        
       let parse_end ~end_date ~end_time ~timezone ~end_timezone =

     

       167
       176
        
         let ( let* ) = Result.bind in

     

       177
       177
       +
         let* _ =

     

       178
       178
       +
           match timezone with

     

       179
       179
       +
           | None -> Ok ()

     

       180
       180
       +
           | Some tzid -> (

     

       181
       181
       +
               match Timedesc.Time_zone.make tzid with

     

       182
       182
       +
               | Some _ -> Ok ()

     

       183
       183
       +
               | None ->

     

       184
       184
       +
                   Error (`Msg (Printf.sprintf "Warning: Unknown timezone %s" tzid)))

     

       185
       185
       +
         in

     

       186
       186
       +
         let* _ =

     

       187
       187
       +
           match end_timezone with

     

       188
       188
       +
           | None -> Ok ()

     

       189
       189
       +
           | Some tzid -> (

     

       190
       190
       +
               match Timedesc.Time_zone.make tzid with

     

       191
       191
       +
               | Some _ -> Ok ()

     

       192
       192
       +
               | None ->

     

       193
       193
       +
                   Error (`Msg (Printf.sprintf "Warning: Unknown timezone %s" tzid)))

     

       194
       194
       +
         in

     

       168
       195
        
         match end_date with

     

       169
       196
        
         | None ->

     

       170
       197
        
             let* _ =

+5 -1

lib/date.ml

···

       380
       380
        
             let dt = Timedesc.of_date_and_time_exn ~tz date time in

     

       381
       381
        
             timedesc_to_ptime dt

     

       382
       382
        
         | `Datetime (`With_tzid (t, (_, tzid))) ->

     

       383
       383
       -
             let tz = Timedesc.Time_zone.make_exn tzid in

     

       383
       383
       +
             let tz =

     

       384
       384
       +
               match Timedesc.Time_zone.make tzid with

     

       385
       385
       +
               | Some tz -> tz

     

       386
       386
       +
               | None -> failwith (Printf.sprintf "Warning: Unknown timezone %s" tzid)

     

       387
       387
       +
             in

     

       384
       388
        
             (* Icalendar gives us the Ptime in UTC, which we parse to a Timedesc *)

     

       385
       389
        
             let ts = Timedesc.Utils.timestamp_of_ptime t in

     

       386
       390
        
             let dt =