commit 457459854d32158a359e5873779a20eb1b934b9b · ryan.freumh.org/caledonia

+36 -20

lib/event.ml

···

       118
       118
        
         { collection; file; event; calendar }

     

       119
       119
        
       

     

       120
       120
        
       let events_of_icalendar collection ~file calendar =

     

       121
       121
       -
         List.filter_map

     

       122
       122
       -
           (function

     

       123
       123
       -
             | `Event event -> Some { collection; file; event; calendar } | _ -> None)

     

       124
       124
       -
           (snd calendar)

     

       121
       121
       +
         let remove_dup_ids lst =

     

       122
       122
       +
           let rec aux acc = function

     

       123
       123
       +
             | [] -> acc

     

       124
       124
       +
             | x :: xs ->

     

       125
       125
       +
                 if List.exists (fun r -> r.uid = x.uid) acc then aux acc xs

     

       126
       126
       +
                 else aux (x :: acc) xs

     

       127
       127
       +
           in

     

       128
       128
       +
           aux [] lst

     

       129
       129
       +
         in

     

       130
       130
       +
         let events =

     

       131
       131
       +
           List.filter_map

     

       132
       132
       +
             (function `Event event -> Some event | _ -> None)

     

       133
       133
       +
             (snd calendar)

     

       134
       134
       +
         in

     

       135
       135
       +
         let events = remove_dup_ids events in

     

       136
       136
       +
         List.map (function event -> { collection; file; event; calendar }) events

     

       125
       137
        
       

     

       126
       138
        
       let to_ical_event t = t.event

     

       127
       139
        
       let to_ical_calendar t = t.calendar

     
···

       200
       212
        
       let get_recurrence t = Option.map (fun r -> snd r) t.event.rrule

     

       201
       213
        
       let get_collection t = t.collection

     

       202
       214
        
       let get_file t = t.file

     

       203
       203
       -
       

     

       204
       204
       -
       let get_recurrence_ids t =

     

       205
       205
       -
         let _, recurrence_ids =

     

       206
       206
       -
           match

     

       207
       207
       -
             List.partition (function `Event _ -> true | _ -> false) (snd t.calendar)

     

       208
       208
       -
           with

     

       209
       209
       -
           | `Event hd :: tl, _ ->

     

       210
       210
       -
               (hd, List.map (function `Event e -> e | _ -> assert false) tl)

     

       211
       211
       -
           | _ -> assert false

     

       212
       212
       -
         in

     

       213
       213
       -
         recurrence_ids

     

       214
       215
        
       

     

       215
       216
        
       type comparator = t -> t -> int

     

       216
       217
        
       

     
···

       627
       628
        
             in

     

       628
       629
        
             let generator =

     

       629
       630
        
               let ical_event = to_ical_event event in

     

       630
       630
       -
               let recurrence_ids = get_recurrence_ids event in

     

       631
       631
       -
               Fmt.pr "Event:\n%s\n" (format_event ~format:`Entries (clone_with_event event ical_event));

     

       632
       632
       -
               List.iter (fun e ->

     

       633
       633
       -
                 Fmt.pr "Recurrent ID event:\n%s\n" (format_event ~format:`Entries (clone_with_event event e))) recurrence_ids;

     

       634
       634
       -
               recur_events ~recurrence_ids ical_event

     

       631
       631
       +
               (* The first event is the non recurrence-id one *)

     

       632
       632
       +
               let _, other_events =

     

       633
       633
       +
                 match

     

       634
       634
       +
                   List.partition

     

       635
       635
       +
                     (function `Event _ -> true | _ -> false)

     

       636
       636
       +
                     (snd event.calendar)

     

       637
       637
       +
                 with

     

       638
       638
       +
                 | `Event hd :: tl, _ ->

     

       639
       639
       +
                     (hd, List.map (function `Event e -> e | _ -> assert false) tl)

     

       640
       640
       +
                 | _ -> assert false

     

       641
       641
       +
               in

     

       642
       642
       +
               Fmt.pr "Event:\n%s\n"

     

       643
       643
       +
                 (format_event ~format:`Entries (clone_with_event event ical_event));

     

       644
       644
       +
               List.iter

     

       645
       645
       +
                 (fun e ->

     

       646
       646
       +
                   Fmt.pr "Recurrent ID event:\n%s\n"

     

       647
       647
       +
                     (format_event ~format:`Entries (clone_with_event event e)))

     

       648
       648
       +
                 other_events;

     

       649
       649
       +
               (* Icalendar filters for equal uids *)

     

       650
       650
       +
               recur_events ~recurrence_ids:other_events ical_event

     

       635
       651
        
             in

     

       636
       652
        
             collect generator []

-1

lib/event.mli

···

       72
       72
        
       val get_recurrence : t -> Icalendar.recurrence option

     

       73
       73
        
       val get_collection : t -> Collection.t

     

       74
       74
        
       val get_file : t -> Eio.Fs.dir_ty Eio.Path.t

     

       75
       75
       -
       val get_recurrence_ids : t -> Icalendar.event list

     

       76
       75
        
       

     

       77
       76
        
       type comparator = t -> t -> int

     

       78
       77
        
       (** Event comparator function type *)