private static ICollection <DateTime> GenerateDays(DateTime?start = null, DateTime?end = null, int?weeks = 5,
DayOfWeekFlags daysOfWeek = DayOfWeekFlags.Weekdays)
{
start = start ?? DateTime.Today;
end = end ?? DateTime.MaxValue;
if (start < DateTime.Now)
{
start = DateTime.Today;
}
var next = daysOfWeek.CalculateDistanceToNextDay();
var date = start.Value;
var dates = new List <DateTime>();
while ((date - start.Value).TotalDays / 7 < weeks && date <= end)
{
dates.Add(date);
var step = next[date.DayOfWeek];
date = date.AddDays(step);
}
return(dates);
}
static void Main(string[] args)
{
DayOfWeekFlags lectureDay = DayOfWeekFlags.Monday; //create variable and initializat it
var exerciseDay = DayOfWeekFlags.Monday | DayOfWeekFlags.Thursday;
var informaticsDays = lectureDay | exerciseDay; //combine flag
bool hasInfOnThursday = (informaticsDays & DayOfWeekFlags.Thursday) == DayOfWeekFlags.Thursday; // true
bool hasInfOnWeekends = (informaticsDays & DayOfWeekFlags.Weekend) == DayOfWeekFlags.Weekend; // false
}
IEnumerable <DayOfWeek> GetDaysOfWeek(DayOfWeekFlags daysOfWeek)
{
for (int i = 0; i < 7; i++)
{
if (((int)daysOfWeek & (int)Math.Pow(2, i)) != 0)
{
yield return((DayOfWeek)i);
}
}
}
public EveryNthWeekOnSpecifiedDaysStrategy(DayOfWeekFlags daysOfWeek = DayOfWeekFlags.EveryDay, int n = 1)
{
if (daysOfWeek < DayOfWeekFlags.Sunday || daysOfWeek > DayOfWeekFlags.EveryDay)
{
throw new ArgumentOutOfRangeException("daysOfWeek is outside the valid range");
}
_n = n;
_daysOfWeek = GetDaysOfWeek(daysOfWeek).ToList();
}
public int?GetFrequencyInterval()
{
switch (this.RecurrenceOption)
{
case ScheduleRecurrence.Daily:
return((int)(this.DailyWeekdaysOnly ? DayOfWeekFlags.WeekDays : DayOfWeekFlags.Any));
case ScheduleRecurrence.SemiMonthly:
return((int)DayOfWeekFlags.None);
case ScheduleRecurrence.Monthly:
DayOfWeekFlags monthlyDayOfWeek = DayOfWeekFlags.None;
if (!this.MonthlyOnSpecificDays)
{
monthlyDayOfWeek = this.MonthlyDayOption;
}
return((int)monthlyDayOfWeek);
case ScheduleRecurrence.Weekly:
DayOfWeekFlags weeklyDayOfWeek = DayOfWeekFlags.None;
if (this.WeeklyOnMonday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Monday;
}
if (this.WeeklyOnTuesday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Tuesday;
}
if (this.WeeklyOnWednesday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Wednesday;
}
if (this.WeeklyOnThursday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Thursday;
}
if (this.WeeklyOnFriday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Friday;
}
if (this.WeeklyOnSaturday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Saturday;
}
if (this.WeeklyOnSunday)
{
weeklyDayOfWeek = weeklyDayOfWeek | DayOfWeekFlags.Sunday;
}
return((int)weeklyDayOfWeek);
default:
return((int)DayOfWeekFlags.Any);
}
}
private bool IsDayIncluded(DateTime dateTime)
{
int?dayMask = this.GetFrequencyInterval();
if (!dayMask.HasValue)
{
dayMask = (int)DayOfWeekFlags.None;
}
DayOfWeekFlags flags = (DayOfWeekFlags)Enum.Parse(typeof(DayOfWeekFlags), dateTime.DayOfWeek.ToString());
return((flags & (DayOfWeekFlags)dayMask.Value) != 0);
}
public static IList <DateTime> GetDaysOfWeek(this DateTime date, DayOfWeekFlags days)
{
var daysOfWeek = days.ToDays();
var dates = new DateTime[daysOfWeek.Count];
for (int i = 0; i < dates.Length; i++)
{
dates[i] = date.GetDayOfWeek(daysOfWeek[i]);
}
return(dates);
}
public static IDictionary <DayOfWeek, int> CalculateDistanceToNextDay(this DayOfWeekFlags flags)
{
var days = flags.ToDays();
return(Enum.GetValues(typeof(DayOfWeek)).Cast <DayOfWeek>().ToDictionary(d => d,
d =>
{
var value = d;
do
{
value = (int)value == 6 ? 0 : value + 1;
} while (!days.Contains(value));
return (value <= d ? (int)value + 7 : (int)value) - (int)d;
}));
}
public static IList <DayOfWeek> ToDays(this DayOfWeekFlags flags)
{
var count = 0;
for (var i = 0; i < 8; i++)
{
var mask = 1 << i;
if (((int)flags & mask) == mask)
{
count++;
}
}
var days = new DayOfWeek[count];
for (int i = 0, bit = 0; i < count; i++, bit++)
{
var mask = 1 << bit;
while (((int)flags & mask) != mask)
{
mask = 1 << ++bit;
}
var day = (DayOfWeekFlags)mask;
switch (day)
{
case DayOfWeekFlags.Monday:
days[i] = DayOfWeek.Monday;
break;
case DayOfWeekFlags.Tuesday:
days[i] = DayOfWeek.Tuesday;
break;
case DayOfWeekFlags.Wednesday:
days[i] = DayOfWeek.Wednesday;
break;
case DayOfWeekFlags.Thursday:
days[i] = DayOfWeek.Thursday;
break;
case DayOfWeekFlags.Friday:
days[i] = DayOfWeek.Friday;
break;
case DayOfWeekFlags.Saturday:
days[i] = DayOfWeek.Saturday;
break;
case DayOfWeekFlags.Sunday:
days[i] = DayOfWeek.Sunday;
break;
default:
break;
}
}
return(days);
}
private static async Task <Settings> LoadSettingsAsync()
{
Console.WriteLine($"Reading {settingsFileName}");
var settingsText = await File.ReadAllTextAsync(settingsFileName);
var settings = JsonConvert.DeserializeObject <Settings>(settingsText, new IsoDateTimeConverter {
DateTimeFormat = "dd-MMM-yy"
});
Console.WriteLine($"Reading {keyFileName}");
settings.ServiceAccountKey = await File.ReadAllTextAsync(keyFileName);
if (settings.EventTitle == null)
{
settings.EventTitle = new List <string>()
{
"P{{period}}.", "{{class}}", "({{teacher}})"
};
}
if (settings.Days.IsSet)
{
settings.Days.UseDefaults();
Console.WriteLine($"Skipping reading {daysFileName} and generating days instead");
DayOfWeekFlags daysOfWeek = DayOfWeekFlags.None;
if (!String.IsNullOrWhiteSpace(settings.Days.DaysOfWeek))
{
if (!Enum.TryParse(settings.Days.DaysOfWeek, out daysOfWeek))
{
daysOfWeek = DayOfWeekFlags.Weekdays;
}
}
var days = GenerateDays(settings.Days.Start, settings.Days.End, settings.Days.Weeks, daysOfWeek);
settings.DayTypes = days.ToDictionary(day => day, day => day.ToString("ddd"));
}
else
{
Console.WriteLine($"Reading {daysFileName}");
settings.DayTypes = new Dictionary <DateTime, string>();
using (var fs = File.Open(daysFileName, FileMode.Open))
using (var reader = new CsvReader(fs))
{
while (reader.HasMoreRecords)
{
var record = await reader.ReadDataRecordAsync();
if (string.IsNullOrEmpty(record[0]))
{
continue;
}
var date = DateTime.ParseExact(record[0], "dd-MMM-yy", null);
var dayOfWeek = date.ToString("ddd");
if (record.Count > 1)
{
settings.DayTypes.Add(date, record[1] + dayOfWeek);
}
else
{
settings.DayTypes.Add(date, dayOfWeek);
}
}
}
}
return(settings);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="Recurrence"/> class.
/// </summary>
/// <param name="dateStart">The date start</param>
/// <param name="interval">The interval</param>
/// <remarks>Use TimeSpan.Zero as interval for non-recurring events.</remarks>
public Recurrence(DateTimeOffset dateStart, TimeSpan interval)
{
this.dateStart = dateStart;
this.dateEnd = DateTimeOffset.MaxValue;
this.interval = interval;
this.excludedHours = HourFlags.None;
this.excludedDayOfWeeks = DayOfWeekFlags.None;
this.excludedDays = DayFlags.None;
this.excludedMonths = MonthFlags.None;
}
