public static CalendarViewItemsGroup Load(Guid localAccountId, ViewItemSemester semester)
{
var answer = new CalendarViewItemsGroup(localAccountId, semester);
// There's actually nothing to load async here, since classes/schedules are already loaded
return(answer);
}
public void SetSemester(ViewItemSemester semester)
{
foreach (var view in GetViews().OfType <MyMonthView>())
{
view.SetSemester(semester);
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
ViewItemSemester semester = value as ViewItemSemester;
if (semester == null)
{
return(value);
}
// If neither are assigned, do nothing
if (PowerPlannerSending.DateValues.IsUnassigned(semester.Start) && PowerPlannerSending.DateValues.IsUnassigned(semester.End))
{
return("");
}
string start = "";
if (!PowerPlannerSending.DateValues.IsUnassigned(semester.Start))
{
start = semester.Start.ToString("d");
}
string end = "";
if (!PowerPlannerSending.DateValues.IsUnassigned(semester.End))
{
end = semester.End.ToString("d");
}
return(start + " - \n" + end);
}
private static SemesterItemsViewGroup CreateInstance(Guid localAccountId, ViewItemSemester semester, bool trackChanges = true)
{
var answer = new SemesterItemsViewGroup(localAccountId, semester, trackChanges);
answer.LoadingTask = Task.Run(answer.LoadBlocking);
return(answer);
}
private void YearView_OnRequestOpenSemester(object sender, ViewItemSemester e)
{
ViewModel.OpenSemester(e.Identifier);
// Just for iOS, we remove the popup, it doesn't play happy with all popups being cleared
ViewModel.RemoveViewModel();
}
public static string Convert(ViewItemSemester semester)
{
if (semester == null)
{
return("");
}
// If neither are assigned, do nothing
if (PowerPlannerSending.DateValues.IsUnassigned(semester.Start) && PowerPlannerSending.DateValues.IsUnassigned(semester.End))
{
return("");
}
string start = "";
if (!PowerPlannerSending.DateValues.IsUnassigned(semester.Start))
{
start = semester.Start.ToString("d");
}
string end = "";
if (!PowerPlannerSending.DateValues.IsUnassigned(semester.End))
{
end = semester.End.ToString("d");
}
return(start + " - \n" + end);
}
private SemesterItemsViewGroup(Guid localAccountId, ViewItemSemester semester, bool trackChanges = true) : base(localAccountId, trackChanges)
{
if (semester == null)
{
throw new ArgumentNullException("semester");
}
Semester = semester;
}
private AgendaViewItemsGroup(Guid localAccountId, ViewItemSemester semester, DateTime today, bool trackChanges = true) : base(localAccountId, trackChanges)
{
if (semester == null)
{
throw new ArgumentNullException("semester");
}
_semester = semester;
Today = today;
}
private void OpenSemester()
{
ViewItemSemester s = getSemester();
if (s == null)
{
return;
}
OnRequestOpenSemester?.Invoke(this, s);
}
public ClassViewModel(BaseViewModel parent, Guid localAccountId, Guid classId, DateTime today, ViewItemSemester semester) : base(parent)
{
_localAccountId = localAccountId;
ClassId = classId;
_today = today;
_semester = semester;
ListenToItem(classId).Deleted += Class_Deleted;
ListenToLocalEditsFor <DataLayer.DataItems.DataItemMegaItem>().ChangedItems += ItemsLocallyEditedListener_ChangedItems;
}
private void ButtonName_Click(object sender, RoutedEventArgs e)
{
// This will edit the semester
ViewItemSemester s = getSemester();
if (s == null)
{
return;
}
OnRequestEditSemester?.Invoke(this, s);
}
private View CreateSemester(ViewGroup root, ViewItemSemester semester)
{
var view = new ListItemSemesterView(root)
{
DataContext = semester
};
view.OpenSemesterRequested += ListItemSemesterView_OpenSemesterRequested;
view.EditSemesterRequested += ListItemSemesterView_EditSemesterRequested;
return(view);
}
private void Initialize(Guid localAccountId, ViewItemSemester semester)
{
var acct = MainScreenViewModel.CurrentAccount;
if (acct == null)
{
throw new NullReferenceException("MainScreenViewModel.CurrentAccount was null");
}
_showPastCompleteItemsOnFullCalendar = acct.ShowPastCompleteItemsOnFullCalendar;
FirstDayOfWeek = acct.WeekChangesOn;
SemesterItemsViewGroup = SemesterItemsViewGroup.Load(localAccountId, semester);
}
public CalendarViewModel(BaseViewModel parent, Guid localAccountId, ViewItemSemester semester) : base(parent)
{
// iOS uses this to show the day when day before notification is clicked
if (_initialSelectedDate != DateTime.MinValue)
{
NavigationManager.SetSelectedDate(_initialSelectedDate);
NavigationManager.SetDisplayMonth(_initialSelectedDate);
_selectedDate = NavigationManager.GetSelectedDate();
_displayMonth = NavigationManager.GetDisplayMonth();
_initialSelectedDate = DateTime.MinValue;
}
Initialize(localAccountId, semester);
}
private async Task LoadBlocking()
{
var dataStore = await GetDataStore();
DataItemClass[] dataClasses;
DataItemSchedule[] dataSchedules;
DataItemWeightCategory[] dataWeights = null; // Weights are now needed for adding tasks/events
DataItemSemester dataSemester;
using (await Locks.LockDataForReadAsync("ScheduleViewItemsGroup.LoadBlocking"))
{
var timeTracker = TimeTracker.Start();
dataSemester = dataStore.TableSemesters.FirstOrDefault(i => i.Identifier == SemesterId);
if (dataSemester == null)
{
throw new SemesterNotFoundException();
}
dataClasses = dataStore.TableClasses.Where(i => i.UpperIdentifier == SemesterId).ToArray();
Guid[] classIdentifiers = dataClasses.Select(i => i.Identifier).ToArray();
dataSchedules = dataStore.TableSchedules.Where(i => classIdentifiers.Contains(i.UpperIdentifier)).ToArray();
if (_includeWeightCategories)
{
dataWeights = dataStore.TableWeightCategories.Where(i => classIdentifiers.Contains(i.UpperIdentifier)).ToArray();
}
timeTracker.End(3, "ScheduleViewItemsGroup.LoadBlocking loading items from database");
timeTracker = TimeTracker.Start();
var semester = new ViewItemSemester(dataSemester, CreateClass);
semester.FilterAndAddChildren(dataClasses);
foreach (var c in semester.Classes)
{
c.FilterAndAddChildren(dataSchedules);
if (_includeWeightCategories)
{
c.FilterAndAddChildren(dataWeights);
}
}
this.Semester = semester;
timeTracker.End(3, "ScheduleViewItemsGroup.LoadBlocking constructing view items");
}
}
protected override void OnDataChangedEvent(DataChangedEvent e)
{
ViewItemSemester s = Item?.Class?.Semester;
if (s != null)
{
s.HandleDataChangedEvent(e);
Item.HandleDataChangedEvent(e);
// And update the class
var newClass = s.Classes.FirstOrDefault(c => c.Identifier == (Item.DataItem as DataItemMegaItem).UpperIdentifier);
Item.GetType().GetRuntimeProperty("Class").SetValue(Item, newClass);
}
}
public static Task <HolidayViewItemsGroup> LoadAsync(Guid localAccountId, ViewItemSemester semester, DateTime start, DateTime end, bool trackChanges = true)
{
if (semester == null)
{
throw new ArgumentNullException("semester");
}
if (trackChanges)
{
throw new NotImplementedException("Tracking changes currently isn't implemented");
}
start = start.Date;
end = end.Date;
return(CreateLoadTask(localAccountId, semester, start, end, trackChanges));
}
public static SemesterItemsViewGroup Load(Guid localAccountId, ViewItemSemester semester, bool trackChanges = true)
{
if (trackChanges)
{
SemesterItemsViewGroup answer;
lock (_cachedSemesterItems)
{
if (_cachedSemesterItems.TryGetValue(semester.Identifier, out answer))
{
return(answer);
}
answer = CreateInstance(localAccountId, semester, true);
_cachedSemesterItems[semester.Identifier] = answer;
return(answer);
}
}
// If not tracking changes, we'll load a fresh instance
return(CreateInstance(localAccountId, semester, false));
}
public static AddSemesterViewModel CreateForEdit(BaseViewModel parent, ViewItemSemester semesterToEdit)
{
var viewModel = new AddSemesterViewModel(parent)
{
State = OperationState.Editing,
SemesterToEdit = semesterToEdit,
Name = semesterToEdit.Name
};
if (!PowerPlannerSending.DateValues.IsUnassigned(semesterToEdit.Start))
{
viewModel.StartDate = semesterToEdit.Start.Date;
}
if (!PowerPlannerSending.DateValues.IsUnassigned(semesterToEdit.End))
{
viewModel.EndDate = semesterToEdit.End.Date;
}
viewModel.ListenToItem(semesterToEdit.Identifier).Deleted += viewModel.Semester_Deleted;
return(viewModel);
}
public static Task <AgendaViewItemsGroup> LoadAsync(Guid localAccountId, ViewItemSemester semester, DateTime today, bool trackChanges = true)
{
if (semester == null)
{
throw new ArgumentNullException("semester");
}
if (!trackChanges)
{
return(CreateLoadStandalone(localAccountId, semester, today));
}
Task <AgendaViewItemsGroup> answer;
lock (_cache)
{
// We compare exactly on semester reference, since otherwise the children could end up with different class objects than parents.
// We had a bug here where a semester from the widget was being used, which didn't load the weight categories, and previously we were
// comparing by identifier, so it used the cached version which led to a crash.
var matchingCache = _cache.FirstOrDefault(i =>
i.Semester == semester &&
i.Today == today &&
!i.Task.IsCanceled &&
!i.Task.IsFaulted);
if (matchingCache != null)
{
// Note that ideally we would perform a re-filter here to eliminate events that expired today.
// However, if we re-filtered from a background thread and a UI thread was listening to this collection,
// it would throw an exception. Hence we won't do that.
return(matchingCache.Task);
}
answer = CreateLoadTask(localAccountId, semester, today);
_cache.Add(new CacheItem(semester, today, answer));
return(answer);
}
}
private void YearView_OnEditSemesterRequested(object sender, ViewItemSemester e)
{
ViewModel.EditSemester(e);
}
public CacheItem(ViewItemSemester semester, DateTime today, Task <AgendaViewItemsGroup> task)
{
Semester = semester;
Today = today;
Task = task;
}
/// <summary>
/// Throws ArgumentException if class wasn't found
/// </summary>
/// <param name="localAccountId"></param>
/// <param name="classId"></param>
/// <returns></returns>
public static async Task <ClassViewItemsGroup> LoadAsync(Guid localAccountId, Guid classId, DateTime today, ViewItemSemester viewItemSemester, bool includeWeights = true)
{
ClassViewItemsGroup answer = new ClassViewItemsGroup(localAccountId, classId, today);
await answer.LoadAsync(viewItemSemester, includeWeights);
return(answer);
}
public void EditSemester(ViewItemSemester semester)
{
ShowPopup(AddSemesterViewModel.CreateForEdit(MainScreenViewModel, semester));
}
private void ListItemSemesterView_OpenSemesterRequested(object sender, ViewItemSemester e)
{
OnOpenSemesterRequested?.Invoke(this, e);
}
private async Task LoadAsync(ViewItemSemester viewItemSemester, bool includeWeights)
{
await Task.Run(async delegate { await LoadBlocking(viewItemSemester, includeWeights); });
}
public AgendaViewModel(BaseViewModel parent, Guid localAccountId, ViewItemSemester semester, DateTime today) : base(parent)
{
_semester = semester;
Today = today.Date;
}
///// <summary>
///// Eliminates any items that have become expired (like events that have expired)
///// </summary>
//private void Refilter()
//{
// // Beware - can't do this from a background thread or else it would crash things
// // Hence we actually need to only do this from a UI thread and also ensure to put it in the
// // lock so that background threads using cached item don't get messed up
// Guid[] classIdentifiers = Classes.Select(i => i.Identifier).ToArray();
// DateTime todayAsUtc = DateTime.SpecifyKind(DateTime.Today, DateTimeKind.Utc);
// this.Items.RemoveWhere(i => !ShouldIncludeItem(i.DataItem as DataItemMegaItem, classIdentifiers, todayAsUtc);
//}
private static async Task <AgendaViewItemsGroup> CreateLoadTask(Guid localAccountId, ViewItemSemester semester, DateTime today)
{
var answer = new AgendaViewItemsGroup(localAccountId, semester, today, trackChanges: true);
SemesterItemsViewGroup cached = SemesterItemsViewGroup.GetCached(semester.Identifier);
if (cached != null)
{
// Can perform this without locks since we already know we're on UI thread right now,
// and any modifications to the SemesterItems list would need to be on UI thread to occur
await cached.LoadingTask;
answer.PrepareFromCached(cached);
}
else
{
await Task.Run(answer.LoadBlocking);
}
return(answer);
}
private void SemesterView_OnRequestOpenSemester(object sender, ViewItemSemester e)
{
OnRequestOpenSemester?.Invoke(this, e);
}
private static async Task <AgendaViewItemsGroup> CreateLoadStandalone(Guid localAccountId, ViewItemSemester semester, DateTime today)
{
var answer = new AgendaViewItemsGroup(localAccountId, semester, today, trackChanges: false);
await Task.Run(answer.LoadBlocking);
return(answer);
}
