public ZbTask<IEnumerable<EventViewModel>> FetchEventsAsync(DateTime from, DateTime to)
{
if (_calendars.Count == 0) return new ZbTask<IEnumerable<EventViewModel>>(ZbTask.Synchron, () => new List<EventViewModel>());
// first -> the recurrence cache
if (_recurrenceCache == null)
{
_recurrenceCache = MakeFetchTask(DateTime.MinValue, DateTime.MinValue);
}
// make primary task first
var result = MakeFetchTask(from, to);
result.OnResult(t =>
{
var range = (to - from);
MakeFetchTask(from - range, to - range);
MakeFetchTask(from + range, to + range);
})
.OnResult(t =>
{
t.Result = t.Result.Union(_recurrenceCache.Result);
});
return result;
}
private PropertyTask<ReadOnlyCollectionShortcut<SavedListConfigViewModel>> EnsureConfigsTask()
{
if (_configsTask != null) return _configsTask;
return _configsTask = new PropertyTask<ReadOnlyCollectionShortcut<SavedListConfigViewModel>>(
notifier: () =>
{
OnPropertyChanged("Configs");
OnPropertyChanged("ConfigsAsync");
},
createTask: () =>
{
var ctx = ViewModelFactory.CreateNewContext();
var qryTask = ctx.GetQuery<SavedListConfiguration>()
.Where(i => i.Type.ExportGuid == Parent.DataType.ExportGuid) // Parent.DataType might be from FrozenContext
.Where(i => i.Owner == null || i.Owner.ID == this.CurrentPrincipal.ID)
.ToListAsync();
var result = new ZbTask<ReadOnlyCollectionShortcut<SavedListConfigViewModel>>(qryTask);
result
.OnResult(t =>
{
t.Result = new ReadOnlyCollectionShortcut<SavedListConfigViewModel>();
foreach (var cfg in qryTask.Result)
{
var obj = cfg.Configuration.FromXmlString<SavedListConfigurationList>();
foreach (var item in obj.Configs)
{
t.Result.Rw.Add(ViewModelFactory.CreateViewModel<SavedListConfigViewModel.Factory>().Invoke(DataContext, this, item, cfg.Owner != null));
}
}
})
.Finally(() => ctx.Dispose());
return result;
},
set: null);
}
private PropertyTask<IEnumerable<CalendarItemViewModel>> EnsureNextEventsTask()
{
if (_NextEventsTask != null) return _NextEventsTask;
return _NextEventsTask = new PropertyTask<IEnumerable<CalendarItemViewModel>>(
notifier: () =>
{
OnPropertyChanged("NextEvents");
OnPropertyChanged("NextEventsAsync");
},
createTask: () =>
{
var now = DateTime.Now;
var tomorrow = now.Date.AddDays(2).AddSeconds(-1); // I know.... :-(
var fetchCalendar = FetchCalendar();
var fetchTaskFactory = new ZbTask<ZbTask<IEnumerable<EventViewModel>>>(fetchCalendar)
.OnResult(t =>
{
_fetchCache.SetCalendars(fetchCalendar.Result);
t.Result = _fetchCache.FetchEventsAsync(now, tomorrow);
});
return new ZbFutureTask<IEnumerable<EventViewModel>, IEnumerable<CalendarItemViewModel>>(fetchTaskFactory)
.OnResult(t =>
{
t.Result = fetchTaskFactory
.Result
.Result
.SelectMany(e => e.CreateCalendarItemViewModels(now, tomorrow))
.OrderBy(i => i.From.Date)
.ThenByDescending(i => i.IsAllDay)
.ThenBy(i => i.From.TimeOfDay)
.ToList();
});
},
set: (IEnumerable<CalendarItemViewModel> value) =>
{
throw new NotImplementedException();
});
}
private void TriggerPossibleValuesROAsync()
{
if (_getPossibleValuesROTask == null)
{
var task = GetPossibleValuesAsync();
_getPossibleValuesROTask = new ZbTask<ReadOnlyObservableCollection<TagEntryViewModel>>(task);
_getPossibleValuesROTask.OnResult(t =>
{
_possibleValues = new ObservableCollection<TagEntryViewModel>(task.Result);
_possibleValuesRO = new ReadOnlyObservableCollection<TagEntryViewModel>(_possibleValues);
EnsureValuePossible(Value);
OnPropertyChanged("PossibleValuesAsync");
OnPropertyChanged("FilteredPossibleValuesAsync");
});
}
}
public void ResetPossibleValues()
{
_possibleValues = null;
_possibleValuesRO = null;
_getPossibleValuesROTask = null;
OnPropertyChanged("PossibleValues");
OnPropertyChanged("PossibleValuesAsync");
}
public void SetCalendars(IEnumerable<int> ids)
{
// better implementation necessary
_recurrenceCache = null;
_cache.Clear();
_calendars.Clear();
_calendars.AddRange(ids);
}
public void Invalidate()
{
_recurrenceCache = null;
_cache.Clear();
}
public FetchCacheEntry(ZbTask<List<EventViewModel>> events)
{
this.FetchTime = DateTime.Now;
this.EventsTask = events;
}
