2021-08-21 00:15:37 -04:00
using System ;
using System.Collections.Concurrent ;
using System.Collections.Generic ;
using System.Linq ;
using Ical.Net ;
using Ical.Net.CalendarComponents ;
using Ical.Net.Serialization ;
namespace director
{
public class iCalHoopJumping
{
private static DateTime searchStart = DateTime . Now ; //is it slower to just call datetime.now every time? /shrug
private static DateTime searchEnd = DateTime . Now . AddDays ( 7 ) ;
public static readonly ConcurrentDictionary < string , Calendar > Calendars = new ConcurrentDictionary < string , Calendar > ( ) ;
2021-10-13 09:25:03 -04:00
public static string LoadCalendar ( string calendarString )
2021-08-21 00:15:37 -04:00
{
2021-10-13 09:25:03 -04:00
var cal = Calendar . Load ( calendarString ) ;
var key = cal . Properties [ "X-WR-CALNAME" ] . Value . ToString ( ) ;
Calendars [ key ] = cal ;
return key ;
2021-08-21 00:15:37 -04:00
}
//I don't understand why the entire .net ecosystem insists on ignoring ToString(). Is it really that much fun writing ThingSerializerFactory? ...java programmers.
private static EventSerializer ser = new EventSerializer ( ) ;
2021-09-03 11:44:44 -04:00
public static CalendarEvent parseEvent ( string calendarLabel , string eventStr )
2021-08-21 00:15:37 -04:00
{
//return new CalendarEvent(eventStr); //lol no
//return CalendarEvent.Parse(eventStr); //lol no
2021-09-03 11:44:44 -04:00
var cal = Calendar . Load ( Program . scratch . Calendars [ calendarLabel ] ) ;
2021-08-21 00:15:37 -04:00
foreach ( var evt in cal . Events )
{
if ( ser . SerializeToString ( evt ) = = eventStr )
{
return evt ;
}
foreach ( var occ in evt . GetOccurrences ( DateTime . Now - TimeSpan . FromDays ( 365 ) , DateTime . Now + TimeSpan . FromDays ( 365 ) ) )
{
var newEvent = occ . Source as Ical . Net . CalendarComponents . CalendarEvent ;
if ( ser . SerializeToString ( newEvent ) = = eventStr )
{
return newEvent ;
}
}
}
return null ;
}
internal static string Event_ToString ( CalendarEvent asEvent )
{
//return asEvent.ToString(); //lol no
2021-10-13 09:25:03 -04:00
if ( asEvent = = null ) { return null ; }
2021-08-21 00:15:37 -04:00
return ser . SerializeToString ( asEvent ) ;
}
public static IEnumerable < CalendarOccurrence > getOccurrences ( string calLabel )
{
var usefulList = new List < CalendarOccurrence > ( ) ;
2021-10-13 09:25:03 -04:00
foreach ( var icalOcc in Calendars [ calLabel ] . GetOccurrences ( searchStart , searchEnd ) )
2021-08-21 00:15:37 -04:00
{
var asEvent = icalOcc . Source as Ical . Net . CalendarComponents . CalendarEvent ;
var newCO = new CalendarOccurrence ( ) ;
newCO . CalendarSourceName = calLabel ;
newCO . _event = asEvent ;
newCO . OccurrenceStart = icalOcc . Period . StartTime . AsSystemLocal ;
newCO . OccurrenceEnd = icalOcc . Period . EndTime . AsSystemLocal ;
usefulList . Add ( newCO ) ;
}
return usefulList ;
}
public class CalendarOccurrence
{
internal string CalendarSourceName { get ; set ; }
internal CalendarEvent _event { get ; set ; }
public string Event
{
get
{
return iCalHoopJumping . Event_ToString ( _event ) ;
}
}
public DateTime OccurrenceStart { get ; set ; }
public DateTime OccurrenceEnd { get ; set ; }
}
}
}