public bool MatchMonthDay(PlannedRecurrenceEntity plannedRecurrence, DateTime date)
{
if (string.IsNullOrEmpty(plannedRecurrence.EveryMonthDay))
{
return(true);
}
List <int> dayList;
try
{
dayList = plannedRecurrence.EveryMonthDay.Split(',').Select(int.Parse).ToList();
}
catch (Exception e)
{
if (e is OverflowException || e is FormatException)
{
_logger.LogWarning(
$"Can't parse EveryMonthDay for PlannedRecurrenceUid = {plannedRecurrence.Uid}, Value = '{plannedRecurrence.EveryMonthDay}'");
return(true);
}
throw;
}
int lastDay = DateTime.DaysInMonth(date.Year, date.Month);
if (dayList.Any(x => x > lastDay))
{
dayList.Add(lastDay);
}
return(dayList.Contains(date.Day));
}
private async Task <bool> SavePlannedRecurrence(PlannedRecurrenceDto dto, string userId)
{
if (dto.IsDeleted)
{
await _plannedRecurrenceRepository.DeleteAsync(dto.Uid);
return(true);
}
PlannedRecurrenceEntity entity = await _plannedRecurrenceRepository.GetByIdAsync(dto.Uid);
if (entity == null)
{
entity = _mapper.Map <PlannedRecurrenceEntity>(dto);
entity.UserId = userId;
await _plannedRecurrenceRepository.UpsertAsync(entity);
return(true);
}
if (!RecurrenceIsChanged(entity, dto))
{
return(false);
}
entity.Task = dto.Task;
entity.StartDate = dto.StartDate;
entity.EndDate = dto.EndDate;
entity.EveryNthDay = dto.EveryNthDay;
entity.EveryWeekday = dto.EveryWeekday;
entity.EveryMonthDay = dto.EveryMonthDay;
var(success, _) = await _plannedRecurrenceRepository.TryUpdateVersionAsync(entity);
return(success);
}
public bool MatchWeekday(PlannedRecurrenceEntity plannedRecurrence, DateTime date)
{
if (!plannedRecurrence.EveryWeekday.HasValue)
{
return(true);
}
RecurrenceWeekdayEnum weekday;
switch (date.DayOfWeek)
{
case DayOfWeek.Sunday: weekday = RecurrenceWeekdayEnum.Sunday; break;
case DayOfWeek.Monday: weekday = RecurrenceWeekdayEnum.Monday; break;
case DayOfWeek.Tuesday: weekday = RecurrenceWeekdayEnum.Tuesday; break;
case DayOfWeek.Wednesday: weekday = RecurrenceWeekdayEnum.Wednesday; break;
case DayOfWeek.Thursday: weekday = RecurrenceWeekdayEnum.Thursday; break;
case DayOfWeek.Friday: weekday = RecurrenceWeekdayEnum.Friday; break;
case DayOfWeek.Saturday: weekday = RecurrenceWeekdayEnum.Saturday; break;
default:
throw new ArgumentOutOfRangeException();
}
return(plannedRecurrence.EveryWeekday.Value.HasFlag(weekday));
}
private bool RecurrenceIsChanged(PlannedRecurrenceEntity entity, PlannedRecurrenceDto dto)
{
return(!string.Equals(entity.Task, dto.Task) ||
entity.StartDate != dto.StartDate ||
entity.EndDate != dto.EndDate ||
entity.EveryNthDay != dto.EveryNthDay ||
entity.EveryWeekday != dto.EveryWeekday ||
!string.Equals(entity.EveryMonthDay, dto.EveryMonthDay));
}
private TaskEntity CreateTaskFromRecurrence(PlannedRecurrenceEntity plannedRecurrence, DateTime date)
{
TaskDto dto = _taskParserService.ParseTask(plannedRecurrence.Task, ignoreDate: true);
var task = _mapper.Map <TaskEntity>(dto);
task.Date = date;
task.UserId = plannedRecurrence.UserId;
task.Uid = Guid.NewGuid().ToString();
return(task);
}
public bool MatchNthDay(PlannedRecurrenceEntity plannedRecurrence, DateTime date)
{
if (!plannedRecurrence.EveryNthDay.HasValue)
{
return(true);
}
TimeSpan dayCount = plannedRecurrence.StartDate.Date - date.Date;
return(dayCount.Days % plannedRecurrence.EveryNthDay == 0);
}
private async Task Upsert(PlannedRecurrenceEntity pgPlannedRecurrence)
{
var mongoPlannedRecurrence = new TaskServiceApp.Entities.Models.PlannedRecurrenceEntity()
{
Task = pgPlannedRecurrence.Task,
StartDate = DateTime.SpecifyKind(pgPlannedRecurrence.StartDate, DateTimeKind.Utc),
EndDate = pgPlannedRecurrence.EndDate.HasValue ? DateTime.SpecifyKind(pgPlannedRecurrence.EndDate.Value, DateTimeKind.Utc) : null,
EveryNthDay = pgPlannedRecurrence.EveryNthDay,
EveryMonthDay = pgPlannedRecurrence.EveryMonthDay,
EveryWeekday = (RecurrenceWeekdayEnum?)(int?)pgPlannedRecurrence.EveryWeekday,
UserId = pgPlannedRecurrence.UserId,
Recurrences = new List <TaskServiceApp.Entities.Models.RecurrenceEntity>(),
Uid = pgPlannedRecurrence.Id.ToString(),
IsDeleted = pgPlannedRecurrence.IsDeleted,
Version = 1,
};
await _mongoPlannedRecurrences.UpsertAsync(mongoPlannedRecurrence);
}
private async Task <PlannedRecurrenceEntity> SaveRecurrence(PlannedRecurrenceEntity entity,
RecurrenceEntity recurrence)
{
bool success;
do
{
entity.Recurrences.Add(recurrence);
PlannedRecurrenceEntity currentEntity;
(success, currentEntity) = await _plannedRecurrenceRepository
.TryUpdateVersionPropsAsync(entity, x => x.Recurrences);
if (!success)
{
entity = currentEntity;
}
} while (!success);
return(entity);
}
private ICollection <DateTime> EvaluateRecurrenceDatesWithinPeriod(PlannedRecurrenceEntity plannedRecurrence, int timezoneOffset)
{
var(periodStart, periodEnd) = EvaluatePeriod(timezoneOffset);
var dates = new List <DateTime>();
for (DateTime i = periodStart; i != periodEnd; i = i.AddDays(1))
{
if (!HasSchedule(plannedRecurrence) ||
!MatchPeriod(plannedRecurrence, i) ||
!MatchWeekday(plannedRecurrence, i) ||
!MatchNthDay(plannedRecurrence, i) ||
!MatchMonthDay(plannedRecurrence, i))
{
continue;
}
dates.Add(i);
}
return(dates);
}
public bool MatchPeriod(PlannedRecurrenceEntity plannedRecurrence, DateTime date)
{
return(date >= plannedRecurrence.StartDate &&
(!plannedRecurrence.EndDate.HasValue || date <= plannedRecurrence.EndDate));
}
private bool HasSchedule(PlannedRecurrenceEntity plannedRecurrence)
{
return(plannedRecurrence.EveryNthDay.HasValue ||
plannedRecurrence.EveryWeekday.HasValue ||
!string.IsNullOrEmpty(plannedRecurrence.EveryMonthDay));
}
