commit 2ccf4bc1f2b444659fc1d98c8692dc125c7c9745 · ryan.freumh.org/caledonia

+8 -6

bin/event_args.ml

···

       139
       139
        
                   Date.parse_date ~tz:Timedesc.Time_zone.utc start_date `From

     

       140
       140
        
                 in

     

       141
       141
        
                 let date = Ptime.to_date ptime in

     

       142
       142
       -
                 Ok (Some (`Date date))

     

       142
       142
       +
                 Ok (Some (Icalendar.Params.singleton Valuetype `Date, `Date date))

     

       143
       143
        
             | Some start_time -> (

     

       144
       144
        
                 match timezone with

     

       145
       145
        
                 | None ->

     
···

       152
       152
        
                       Date.parse_date_time ~tz:Timedesc.Time_zone.utc ~date:start_date

     

       153
       153
        
                         ~time:start_time `From

     

       154
       154
        
                     in

     

       155
       155
       -
                     Ok (Some (`Datetime (`With_tzid (datetime, (false, tzid)))))

     

       155
       155
       +
                     Ok (Some (Icalendar.Params.empty, `Datetime (`With_tzid (datetime, (false, tzid)))))

     

       156
       156
        
                 | Some "FLOATING" ->

     

       157
       157
        
                     let* datetime =

     

       158
       158
        
                       Date.parse_date_time ~tz:Timedesc.Time_zone.utc ~date:start_date

     

       159
       159
        
                         ~time:start_time `From

     

       160
       160
        
                     in

     

       161
       161
       -
                     Ok (Some (`Datetime (`Local datetime)))

     

       161
       161
       +
                     Ok (Some (Icalendar.Params.empty, `Datetime (`Local datetime)))

     

       162
       162
        
                 | Some "UTC" ->

     

       163
       163
        
                     let* datetime =

     

       164
       164
        
                       Date.parse_date_time ~tz:Timedesc.Time_zone.utc ~date:start_date

     

       165
       165
        
                         ~time:start_time `From

     

       166
       166
        
                     in

     

       167
       167
       -
                     Ok (Some (`Datetime (`Utc datetime)))

     

       167
       167
       +
                     Ok (Some (Icalendar.Params.empty, `Datetime (`Utc datetime)))

     

       168
       168
        
                 | Some tzid ->

     

       169
       169
        
                     let* datetime =

     

       170
       170
        
                       Date.parse_date_time ~tz:Timedesc.Time_zone.utc ~date:start_date

     

       171
       171
        
                         ~time:start_time `From

     

       172
       172
        
                     in

     

       173
       173
       -
                     Ok (Some (`Datetime (`With_tzid (datetime, (false, tzid)))))))

     

       173
       173
       +
                     Ok (Some (Icalendar.Params.empty, `Datetime (`With_tzid (datetime, (false, tzid)))))))

     

       174
       174
        
       

     

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

     

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

     
···

       219
       219
        
                 let* ptime =

     

       220
       220
        
                   Date.parse_date end_date ~tz:Timedesc.Time_zone.utc `From

     

       221
       221
        
                 in

     

       222
       222
       +
                 (* DTEND;VALUE=DATE the event ends at the start of the specified date *)

     

       223
       223
       +
                 let ptime = Date.add_days ptime 1 in

     

       222
       224
        
                 let date = Ptime.to_date ptime in

     

       223
       223
       -
                 Ok (Some (`Dtend (Icalendar.Params.empty, `Date date)))

     

       225
       225
       +
                 Ok (Some (`Dtend (Icalendar.Params.singleton Valuetype `Date, `Date date)))

     

       224
       226
        
             | Some end_time -> (

     

       225
       227
        
                 match (timezone, end_timezone) with

     

       226
       228
        
                 | None, None ->

+2 -4

lib/event.ml

···

       26
       26
        
           Eio.Path.(

     

       27
       27
        
             fs / calendar_dir_path / (match calendar_name with s -> s) / file_name)

     

       28
       28
        
         in

     

       29
       29
       -
         let dtstart = (Params.empty, start) in

     

       29
       29
       +
         let dtstart = start in

     

       30
       30
        
         let dtend_or_duration = end_ in

     

       31
       31
        
         let rrule = Option.map (fun r -> (Params.empty, r)) recurrence in

     

       32
       32
        
         let now = Ptime_clock.now () in

     
···

       63
       63
        
         let now = Ptime_clock.now () in

     

       64
       64
        
         let uid = t.event.uid in

     

       65
       65
        
         let dtstart =

     

       66
       66
       -
           match start with None -> t.event.dtstart | Some s -> (Params.empty, s)

     

       66
       66
       +
           match start with None -> t.event.dtstart | Some s -> s

     

       67
       67
        
         in

     

       68
       68
        
         let dtend_or_duration =

     

       69
       69
        
           match end_ with None -> t.event.dtend_or_duration | Some _ -> end_

     
···

       169
       169
        
         match t.event.dtstart with

     

       170
       170
        
         | _, `Datetime (`With_tzid (_, (_, tzid))) -> Some tzid

     

       171
       171
        
         | _, `Datetime (`Utc _) -> Some "UTC"

     

       172
       172
       -
         | _, `Datetime (`Local _) -> Some "FLOATING"

     

       173
       172
        
         | _ -> None

     

       174
       173
        
       

     

       175
       174
        
       let get_end_timezone t =

     

       176
       175
        
         match t.event.dtend_or_duration with

     

       177
       176
        
         | Some (`Dtend (_, `Datetime (`With_tzid (_, (_, tzid))))) -> Some tzid

     

       178
       177
        
         | Some (`Dtend (_, `Datetime (`Utc _))) -> Some "UTC"

     

       179
       179
       -
         | Some (`Dtend (_, `Datetime (`Local _))) -> Some "FLOATING"

     

       180
       178
        
         | _ -> None

     

       181
       179
        
       

     

       182
       180
        
       let get_duration t =

+2 -2

lib/event.mli

···

       12
       12
        
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       13
       13
        
         calendar_dir_path:string ->

     

       14
       14
        
         summary:string ->

     

       15
       15
       -
         start:Icalendar.date_or_datetime ->

     

       15
       15
       +
         start:Icalendar.params * Icalendar.date_or_datetime ->

     

       16
       16
        
         ?end_:

     

       17
       17
        
           [ `Duration of Icalendar.params * Ptime.Span.t

     

       18
       18
        
           | `Dtend of Icalendar.params * Icalendar.date_or_datetime ] ->

     
···

       31
       31
        
       

     

       32
       32
        
       val edit :

     

       33
       33
        
         ?summary:string ->

     

       34
       34
       -
         ?start:Icalendar.date_or_datetime ->

     

       34
       34
       +
         ?start:Icalendar.params * Icalendar.date_or_datetime ->

     

       35
       35
        
         ?end_:

     

       36
       36
        
           [ `Duration of Icalendar.params * Ptime.Span.t

     

       37
       37
        
           | `Dtend of Icalendar.params * Icalendar.date_or_datetime ] ->