public GroupedDay(MyObservableList <ViewItemSchedule> allSchedules, DayOfWeek dayOfWeek)
{
DayOfWeek = dayOfWeek;
var date = DateTools.Next(dayOfWeek, DateTime.Today);
Times = allSchedules.Sublist(i => i.OccursOnDate(date));
Times.CollectionChanged += Schedules_CollectionChanged;
ResetVisibility();
}
public void AddWeightChildrenHelper(Func <DataItemWeightCategory, ViewItemWeightCategory> createWeightMethod)
{
WeightCategories = new MyObservableList <ViewItemWeightCategory>();
AddChildrenHelper(new ViewItemChildrenHelper <DataItemWeightCategory, ViewItemWeightCategory>(
isChild: IsChild,
addMethod: Add,
removeMethod: Remove,
createChildMethod: createWeightMethod,
children: WeightCategories));
}
public void AddGradesHelper(Func <BaseDataItemHomeworkExamGrade, BaseViewItemMegaItem> createGradeMethod)
{
Grades = new MyObservableList <BaseViewItemMegaItem>();
AddChildrenHelper(new ViewItemChildrenHelper <BaseDataItemHomeworkExamGrade, BaseViewItemMegaItem>(
isChild: IsChild,
addMethod: Add,
removeMethod: Remove,
createChildMethod: createGradeMethod,
children: Grades));
}
public void AddTasksAndEventsChildrenHelper(Func <DataItemMegaItem, ViewItemTaskOrEvent> createItemMethod, Func <DataItemMegaItem, bool> isChildMethod = null)
{
TasksAndEvents = new MyObservableList <ViewItemTaskOrEvent>();
AddChildrenHelper(new ViewItemChildrenHelper <DataItemMegaItem, ViewItemTaskOrEvent>(
isChild: isChildMethod != null ? isChildMethod : IsTaskOrEventChild,
addMethod: Add,
removeMethod: Remove,
createChildMethod: createItemMethod,
children: TasksAndEvents));
}
private DayScheduleItemsArranger(AccountDataItem account, SemesterItemsViewGroup semesterItems, ScheduleViewItemsGroup scheduleGroup, DateTime date, double heightOfHour, double spacingWhenNoAdditionalItems, double spacingWithAdditionalItems, double widthOfCollapsed, bool includeHomeworkAndHolidays)
{
if (semesterItems.Semester == null)
{
throw new NullReferenceException("Semester was null");
}
_semesterItems = semesterItems;
semesterItems.OnItemsChanged += new WeakEventHandler <EventArgs>(SemesterGroup_OnItemsChanged).Handler;
scheduleGroup.OnChangesOccurred += new WeakEventHandler <DataChangedEvent>(ScheduleViewItemsGroup_OnChangesOccurred).Handler;
Date = date;
_spacingWhenNoAdditionalItems = spacingWhenNoAdditionalItems;
_spacingWithAdditionalItems = spacingWithAdditionalItems;
_widthOfCollapsed = widthOfCollapsed;
Account = account;
_schoolTimeZone = account.SchoolTimeZone;
HeightOfHour = heightOfHour;
MinDuration = TimeSpan.FromHours(widthOfCollapsed / HeightOfHour);
IsDifferentSemester = !semesterItems.Semester.IsDateDuringThisSemester(date);
SchedulesOnDay schedules = null;
if (!IsDifferentSemester)
{
schedules = SchedulesOnDay.Get(semesterItems.Classes, date, account.GetWeekOnDifferentDate(date), trackChanges: true);
schedules.CollectionChanged += new WeakEventHandler <NotifyCollectionChangedEventArgs>(Schedules_CollectionChanged).Handler;
}
_schedules = schedules;
if (includeHomeworkAndHolidays)
{
_events = HomeworksOnDay.Get(semesterItems.Items, date);
_events.CollectionChanged += new WeakEventHandler <NotifyCollectionChangedEventArgs>(Events_CollectionChanged).Handler;
}
else
{
_events = new MyObservableList <BaseViewItemHomeworkExamGrade>();
}
if (includeHomeworkAndHolidays)
{
_holidays = HolidaysOnDay.Create(semesterItems.Items, date);
_holidays.CollectionChanged += new WeakEventHandler <NotifyCollectionChangedEventArgs>(_holidays_CollectionChanged).Handler;
}
else
{
_holidays = new MyObservableList <ViewItemHoliday>();
}
Initialize(schedules, _events, _holidays);
}
public void AddHomeworkAndExamChildrenHelper(Func <DataItemMegaItem, BaseViewItemHomeworkExam> createItemMethod, Func <DataItemMegaItem, bool> isChildMethod = null)
{
HomeworkAndExams = new MyObservableList <BaseViewItems.BaseViewItemHomeworkExam>();
AddChildrenHelper(new ViewItemChildrenHelper <DataItemMegaItem, BaseViewItemHomeworkExam>(
isChild: isChildMethod != null ? isChildMethod : IsHomeworkOrExamChild,
addMethod: Add,
removeMethod: Remove,
createChildMethod: createItemMethod,
children: HomeworkAndExams));
}
public ConfigureClassWeightCategoriesViewModel(BaseViewModel parent, ViewItemClass c) : base(parent)
{
Class = c;
WeightCategories = new MyObservableList <EditingWeightCategoryViewModel>(c.WeightCategories.Select(
i => new EditingWeightCategoryViewModel()
{
Name = i.Name,
Weight = i.WeightValue,
Identifier = i.Identifier
}));
}
public MainCalendarSquare(MainCalendarGrid calendarGrid, DateTime date, MyObservableList<BaseViewItemHomeworkExamGrade> allItems) : base(calendarGrid, date)
{
// Render is called before this
AllowDrop = true;
DragOver += MainCalendarSquare_DragOver;
Drop += MainCalendarSquare_Drop;
_itemsControl.ItemsSource = HomeworksOnDay.Get(allItems, date);
_holidays = HolidaysOnDay.Create(allItems, date);
_holidays.CollectionChanged += new WeakEventHandler<NotifyCollectionChangedEventArgs>(delegate { UpdateIsHoliday(); }).Handler;
UpdateIsHoliday();
}
public MainCalendarGrid(TCalendarView calendarView, DateTime displayMonth, bool isMouseOver, MyObservableList <BaseViewItemHomeworkExamGrade> allItems)
: base(calendarView, displayMonth)
{
_allItems = allItems;
base.Initialize();
base.Background = CalendarView.GridBackground;
if (isMouseOver)
{
ShowArrows();
}
}
public MainCalendarSquare(MainCalendarGrid calendarGrid, DateTime date, MyObservableList <BaseViewItemHomeworkExamGrade> allItems) : base(calendarGrid, date)
{
// Render is called before this
_calendarViewModel = calendarGrid.ViewModel;
_allItems = allItems;
AllowDrop = true;
DragOver += MainCalendarSquare_DragOver;
Drop += MainCalendarSquare_Drop;
_calendarViewModel.PropertyChanged += new WeakEventHandler <PropertyChangedEventArgs>(_calendarViewModel_PropertyChanged).Handler;
UpdateItemsSource();
_holidays = HolidaysOnDay.Create(allItems, date);
_holidays.CollectionChanged += new WeakEventHandler <NotifyCollectionChangedEventArgs>(delegate { UpdateIsHoliday(); }).Handler;
UpdateIsHoliday();
}
public ConfigureClassGradeScaleViewModel(BaseViewModel parent, ViewItemClass c) : base(parent)
{
Class = c;
GradeScales = new MyObservableList <GradeScale>(c.GradeScales.Select(
i => new GradeScale()
{
StartGrade = i.StartGrade,
GPA = i.GPA
}));
foreach (var gradeScale in GradeScales)
{
gradeScale.PropertyChanged += GradeScale_PropertyChanged;
}
}
public MainCalendarGrid(TCalendarView calendarView, DateTime displayMonth, bool isMouseOver, MyObservableList <BaseViewItemMegaItem> allItems, CalendarViewModel viewModel)
: base(calendarView, displayMonth)
{
_allItems = allItems;
ViewModel = viewModel;
base.Initialize();
base.Background = CalendarView.GridBackground;
if (isMouseOver)
{
ShowArrows();
}
}
public ViewItemYear(
DataItemYear dataItem,
Func <DataItemSemester, ViewItemSemester> createSemesterMethod) : base(dataItem)
{
if (createSemesterMethod != null)
{
Semesters = new MyObservableList <ViewItemSemester>();
AddChildrenHelper(new ViewItemChildrenHelper <DataItemSemester, ViewItemSemester>(
isChild: IsChild,
addMethod: Add,
removeMethod: Remove,
createChildMethod: createSemesterMethod,
children: Semesters));
}
}
private void Update(MyObservableList <BaseViewItemHomeworkExam> list)
{
if (list.Count > 0)
{
if (Count == 0)
{
Add(UNASSIGNED_ITEMS_HEADER);
}
}
else
{
if (Count > 0)
{
RemoveAt(0);
}
}
}
public static async System.Threading.Tasks.Task LoadLogins()
{
_logins = new MyObservableList <LoginWin>();
foreach (StorageFolder accountFolder in await(await GetAccountsFolder()).GetFoldersAsync())
{
Guid localAccountId;
if (Guid.TryParse(accountFolder.Name, out localAccountId))
{
LoginWin login = await getLogin(localAccountId);
if (login != null)
{
_logins.Add(login);
}
}
}
}
private async Task LoadBlocking()
{
var dataStore = await GetDataStore();
Guid semesterId = Semester.Identifier;
DateTime startAsUtc = DateTime.SpecifyKind(StartDate, DateTimeKind.Utc);
DateTime endAsUtc = DateTime.SpecifyKind(EndDate, DateTimeKind.Utc);
DataItemMegaItem[] dataItemHolidays;
using (await Locks.LockDataForReadAsync("HolidayViewItemsGroup.LoadBlocking"))
{
dataItemHolidays = dataStore.TableMegaItems.Where(i =>
i.MegaItemType == PowerPlannerSending.MegaItemType.Holiday &&
i.UpperIdentifier == semesterId &&
((i.Date <= startAsUtc && i.EndTime >= startAsUtc) ||
(i.Date >= startAsUtc && i.Date <= endAsUtc))).ToArray();
}
Holidays = new MyObservableList <ViewItemHoliday>(dataItemHolidays.Select(i => new ViewItemHoliday(i)));
}
private async void Initialize()
{
Accounts = new MyObservableList <AccountDataItem>(await AccountsManager.GetAllAccounts());
// TODO: What if RememberUsername is edited? That's quite a minor case, not worth building something for, but it's potentially a flaw
AccountsWithRememberUsername = Accounts.Sublist(i => i.RememberUsername && !i.IsDefaultOfflineAccount);
AccountsManager.OnAccountDeleted += new WeakEventHandler <Guid>(AccountsManager_OnAccountDeleted).Handler;
var lastLoginLocalId = AccountsManager.GetLastLoginLocalId();
if (lastLoginLocalId != Guid.Empty)
{
var lastLogin = Accounts.FirstOrDefault(i => i.LocalAccountId == lastLoginLocalId);
if (lastLogin != null && lastLogin.RememberUsername && !lastLogin.IsDefaultOfflineAccount)
{
Username = lastLogin.Username;
}
}
}
private async Task LoadBlocking()
{
var dataStore = await GetDataStore();
DataItemMegaItem[] dataItems;
using (await Locks.LockDataForReadAsync("AgendaViewItemsGroup.LoadBlocking"))
{
Guid[] classIdentifiers = _semester.Classes.Select(i => i.Identifier).ToArray();
DateTime todayAsUtc = DateTime.SpecifyKind(Today, DateTimeKind.Utc);
dataItems = dataStore.TableMegaItems.Where(ShouldIncludeItemFunction(classIdentifiers, todayAsUtc)).ToArray();
this.Items = new MyObservableList <ViewItemTaskOrEvent>();
foreach (var i in dataItems)
{
Add(i);
}
}
}
public static HomeworksOnDay Get(MyObservableList <BaseViewItemHomeworkExamGrade> mainList, DateTime date)
{
HomeworksOnDay answer;
for (int i = 0; i < _cached.Count; i++)
{
if (_cached[i].TryGetTarget(out answer))
{
if (answer.Date == date.Date && answer.MainList == mainList)
{
return(answer);
}
}
else
{
_cached.RemoveAt(i);
i--;
}
}
answer = new HomeworksOnDay(mainList, date);
_cached.Add(new WeakReference <HomeworksOnDay>(answer));
return(answer);
}
public ClassWin()
{
Homework = new MyObservableList <HomeworkWin>();
Exams = new MyObservableList <ExamWin>();
Schedules = new MyObservableList <ScheduleWin>();
}
public void SetItemsSource(MyObservableList <BaseViewItemMegaItem> items)
{
_itemsControlWrapper.ItemsSource = items;
}
public UnassignedItemsHeaderList(MyObservableList <BaseViewItemHomeworkExam> unassignedItems)
{
unassignedItems.CollectionChanged += new WeakEventHandler <NotifyCollectionChangedEventArgs>(UnassignedItems_CollectionChanged).Handler;
Update(unassignedItems);
}
private void PrepareFromCached(SemesterItemsViewGroup semesterItems)
{
// Hold onto a strong reference of the cached items so they continue updating
_cachedSemesterItems = semesterItems;
this.Items = new AgendaItemsList(Today, semesterItems.Items);
}
private void Initialize(SchedulesOnDay schedules, MyObservableList <BaseViewItemHomeworkExamGrade> events, MyObservableList <ViewItemHoliday> holidays)
{
List <ScheduleItem> schedulesCopied;
if (schedules == null)
{
// Different semester case, so no schedules
schedulesCopied = new List <ScheduleItem>();
}
else
{
schedulesCopied = schedules.Where(i => i.EndTime.TimeOfDay > i.StartTime.TimeOfDay).Select(i => new ScheduleItem(this, i)).ToList();
}
List <EventItem> eventsCopied = new List <EventItem>();
List <BaseViewItemHomeworkExam> allDayEvents = new List <ViewItems.BaseViewItems.BaseViewItemHomeworkExam>();
foreach (var e in events.OfType <BaseViewItemHomeworkExam>())
{
if (e.IsDuringDay())
{
eventsCopied.Add(new EventItem(this, e));
}
else
{
allDayEvents.Add(e);
}
}
AllDayItems = allDayEvents;
Holidays = holidays.ToList();
HasHolidays = Holidays.Any();
_cachedHolidayAndAllDayItems = null;
var schedulesFinal = schedulesCopied.ToArray();
var eventsFinal = eventsCopied.ToList();
ScheduleItems = schedulesFinal;
// Handle schedule collisions
while (schedulesCopied.Count > 0)
{
var collidingSchedules = new List <ScheduleItem>()
{
schedulesCopied[0]
};
schedulesCopied.RemoveAt(0);
AddColliding(schedulesCopied, collidingSchedules);
if (collidingSchedules.Count > 1)
{
for (int i = 0; i < collidingSchedules.Count; i++)
{
collidingSchedules[i].Column = i;
collidingSchedules[i].NumOfColumns = collidingSchedules.Count;
}
}
}
// Handle event collisions
while (eventsCopied.Count > 0)
{
var collidingEvents = new List <EventItem>()
{
eventsCopied[0]
};
eventsCopied.RemoveAt(0);
AddColliding(eventsCopied, collidingEvents);
List <ScheduleItem> scheduleCollisionsWithEvent = new List <ScheduleItem>();
// If there's a colliding schedule, we collapse
bool doesCollideWithSchedule = false;
foreach (var e in collidingEvents)
{
foreach (var s in schedulesFinal)
{
if (s.CollidesWith(e))
{
doesCollideWithSchedule = true;
scheduleCollisionsWithEvent.Add(s);
}
}
}
if (doesCollideWithSchedule)
{
var firstEvent = collidingEvents[0];
firstEvent.IsCollapsedMode = true;
foreach (var e in collidingEvents.Skip(1))
{
firstEvent.AddAdditionalItem(e);
eventsFinal.Remove(e);
}
foreach (var s in scheduleCollisionsWithEvent)
{
if (firstEvent.AdditionalItems != null)
{
s.LeftOffset = _spacingWithAdditionalItems;
}
else
{
// LeftOffset might have been previously assigned, so make sure we're assigning higher value
if (_spacingWhenNoAdditionalItems > s.LeftOffset)
{
s.LeftOffset = _spacingWhenNoAdditionalItems;
}
}
}
}
else if (collidingEvents.Count == 1)
{
// Nothing
}
else if (collidingEvents.Count == 2)
{
// Exactly two items
collidingEvents[0].NumOfColumns = 2;
collidingEvents[1].NumOfColumns = 2;
collidingEvents[1].Column = 1;
}
else
{
// More than two items
EventItem prev = null;
bool isLeftSide = true;
while (collidingEvents.Count > 0)
{
var curr = collidingEvents[0];
curr.NumOfColumns = 2;
collidingEvents.RemoveAt(0);
if (prev != null)
{
if (!isLeftSide)
{
curr.Column = 1;
}
// Find out if any items collide with the prev item, and therefore need to become mini-items with the curr item
while (collidingEvents.Count > 0)
{
var next = collidingEvents[0];
if (prev.CollidesWith(next))
{
collidingEvents.RemoveAt(0);
curr.AddAdditionalItem(next);
eventsFinal.Remove(next);
}
else
{
break;
}
}
}
// Prev becomes curr
prev = curr;
// And we switch the side
isLeftSide = !isLeftSide;
}
}
}
EventItems = eventsFinal.ToArray();
if (ScheduleItems.Any() || EventItems.Any())
{
var min = ScheduleItems.OfType <BaseScheduleItem>().Concat(EventItems.OfType <BaseScheduleItem>()).Min(i => i.StartTime);
if (min.Minutes == 59 && min.Hours != 23)
{
// So that a task that's due before class (1 min before) doesn't cause an entire hour to be rendered, we adjust 0:59 to the next hour
// Note that we exclude incrementing 23:59 since that would make it the next day
min = min.Add(TimeSpan.FromMinutes(1));
}
StartTime = new TimeSpan(min.Hours, 0, 0);
EndTime = new TimeSpan(ScheduleItems.OfType <BaseScheduleItem>().Concat(EventItems.OfType <BaseScheduleItem>()).Max(i => i.EndTime).Hours, 0, 0);
if (EndTime < StartTime)
{
EndTime = StartTime.Add(TimeSpan.FromHours(1));
}
}
CalculateOffsets();
}
public static HolidaysOnDay Create(MyObservableList <BaseViewItemMegaItem> mainList, DateTime date)
{
return(new HolidaysOnDay(mainList.OfTypeObservable <ViewItemHoliday>(), date));
}
public SemesterWin()
{
Classes = new MyObservableList <ClassWin>();
Tasks = new MyObservableList <TaskWin>();
}
public static void Dispose()
{
_logins = null;
_loadedLogins.Clear();
}
public async void LoadGrades()
{
try
{
if (_hasGradesBeenRequested)
{
return;
}
_hasGradesBeenRequested = true;
await Task.Run(async delegate
{
try
{
var dataStore = await GetDataStore();
DataItemGrade[] dataGrades;
DataItemMegaItem[] dataItems;
using (await Locks.LockDataForReadAsync())
{
Guid[] weightIds = this.Class.WeightCategories.Select(i => i.Identifier).ToArray();
dataGrades = dataStore.TableGrades.Where(i => weightIds.Contains(i.UpperIdentifier)).ToArray();
dataItems = dataStore.TableMegaItems.Where(i =>
(i.MegaItemType == PowerPlannerSending.MegaItemType.Exam || i.MegaItemType == PowerPlannerSending.MegaItemType.Homework) &&
i.UpperIdentifier == _classId &&
i.WeightCategoryIdentifier != PowerPlannerSending.BaseHomeworkExam.WEIGHT_CATEGORY_EXCLUDED)
.ToArray();
var unassignedItems = new MyObservableList <BaseViewItemHomeworkExam>();
unassignedItems.InsertSorted(dataItems
.Where(i => IsUnassignedChild(i))
.Select(i =>
i.MegaItemType == PowerPlannerSending.MegaItemType.Homework ?
new ViewItemHomework(i)
{
Class = this.Class, WeightCategory = ViewItemWeightCategory.UNASSIGNED
} as BaseViewItemHomeworkExam
: new ViewItemExam(i)
{
Class = this.Class, WeightCategory = ViewItemWeightCategory.UNASSIGNED
}));
PortableDispatcher.GetCurrentDispatcher().Run(delegate
{
try
{
foreach (var weight in this.Class.WeightCategories)
{
weight.AddGradesHelper(ViewItemWeightCategory.CreateGradeHelper);
weight.FilterAndAddChildren <BaseDataItemHomeworkExamGrade>(dataGrades);
weight.FilterAndAddChildren <BaseDataItemHomeworkExamGrade>(dataItems);
}
Class.CalculateEverything();
UnassignedItems = unassignedItems;
HasUnassignedItems = unassignedItems.Count > 0;
_loadGradesTaskSource.SetResult(true);
IsGradesLoaded = true;
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
});
}
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
});
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public void SetItemsSource(MyObservableList <BaseViewItemHomeworkExamGrade> items)
{
_itemsControlWrapper.ItemsSource = items;
}
public async void LoadHomeworkAndExams()
{
try
{
if (_hasHomeworkAndExamsBeenRequested)
{
return;
}
_hasHomeworkAndExamsBeenRequested = true;
bool hasPastCompletedHomework = false;
bool hasPastCompletedExams = false;
SemesterItemsViewGroup cached = null;
if (this.Class.Semester != null)
{
cached = SemesterItemsViewGroup.GetCached(this.Class.Semester.Identifier);
}
if (cached != null)
{
await cached.LoadingTask;
DataItemMegaItem[] dataMegaItems = cached.Items
.OfType <BaseViewItemHomeworkExam>()
.Select(i => i.DataItem)
.OfType <DataItemMegaItem>()
.ToArray();
this.Class.AddHomeworkAndExamChildrenHelper(CreateHomeworkOrExam, ShouldIncludeHomeworkOrExamFunction(_classId, TodayAsUtc));
this.Class.FilterAndAddChildren(dataMegaItems);
hasPastCompletedHomework = dataMegaItems.Any(IsPastCompletedHomeworkFunction(_classId, TodayAsUtc));
hasPastCompletedExams = dataMegaItems.Any(IsPastCompletedExamFunction(_classId, TodayAsUtc));
}
else
{
await Task.Run(async delegate
{
var dataStore = await GetDataStore();
DataItemMegaItem[] dataHomeworks;
using (await Locks.LockDataForReadAsync())
{
dataHomeworks = dataStore.TableMegaItems.Where(ShouldIncludeHomeworkOrExamFunction(_classId, TodayAsUtc)).ToArray();
this.Class.AddHomeworkAndExamChildrenHelper(CreateHomeworkOrExam, ShouldIncludeHomeworkOrExamFunction(_classId, TodayAsUtc));
this.Class.FilterAndAddChildren(dataHomeworks);
hasPastCompletedHomework = dataStore.TableMegaItems.Any(IsPastCompletedHomeworkFunction(_classId, TodayAsUtc));
hasPastCompletedExams = dataStore.TableMegaItems.Any(IsPastCompletedExamFunction(_classId, TodayAsUtc));
}
});
}
HasPastCompletedHomework = hasPastCompletedHomework;
HasPastCompletedExams = hasPastCompletedExams;
Homework = this.Class.HomeworkAndExams.Sublist(ShouldIncludeInNormalHomeworkFunction(TodayAsUtc)).Cast <ViewItemHomework>();
Exams = new MyObservableList <ViewItemExam>();
(Exams as MyObservableList <ViewItemExam>).InsertSorted(
this.Class.HomeworkAndExams.Sublist(ShouldIncludeInNormalExamsFunction()).Cast <ViewItemExam>());
OnPropertyChanged(nameof(Homework));
OnPropertyChanged(nameof(Exams));
_loadHomeworkAndExamsCompletionSource.SetResult(true);
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
