private void _spinnerWeightCategory_ItemSelected(object sender, AdapterView.ItemSelectedEventArgs e)
{
ViewItemWeightCategory w = ViewModel.WeightCategories.ElementAtOrDefault(e.Position);
if (w != null)
{
ViewModel.SelectedWeightCategory = w;
}
}
public static AddGradeViewModel CreateForEdit(BaseViewModel parent, EditParameter editParams)
{
ViewItemWeightCategory weight = editParams.Item.WeightCategory;
ViewItemClass c;
if (editParams.Item is ViewItemTaskOrEvent item)
{
c = item.Class;
}
else
{
if (weight == null)
{
throw new NullReferenceException("WeightCategory was null");
}
c = weight.Class;
}
if (c == null)
{
throw new NullReferenceException("Class was null");
}
if (weight == null || weight == ViewItemWeightCategory.UNASSIGNED || weight == ViewItemWeightCategory.EXCLUDED)
{
weight = c.WeightCategories.FirstOrDefault(i => i.Identifier == NavigationManager.SelectedWeightCategoryIdentifier);
if (weight == null)
{
weight = c.WeightCategories.FirstOrDefault();
}
if (weight == null)
{
throw new InvalidOperationException("No weight categories found for class");
}
}
return(new AddGradeViewModel(parent)
{
State = editParams.IsInWhatIfMode ? OperationState.EditingWhatIf : OperationState.Editing,
Name = editParams.Item.Name,
Date = editParams.Item.DateInSchoolTime,
Details = editParams.Item.Details,
WeightCategories = c.WeightCategories,
SelectedWeightCategory = weight,
IsDropped = editParams.Item.IsDropped,
GradeReceived = editParams.Item.GradeReceived,
GradeTotal = editParams.Item.GradeTotal,
_editingGrade = editParams.Item,
_onSaved = editParams.OnSaved,
IsUnassignedItem = editParams.IsUnassignedItem,
_originalDateOffset = editParams.Item.Date.TimeOfDay,
_showViewGradeSnackbarAfterSaving = editParams.ShowViewGradeSnackbarAfterSaving
});
}
public static AddGradeViewModel CreateForAdd(BaseViewModel parent, AddParameter addParams)
{
DateTime?date = NavigationManager.GetPreviousAddItemDate();
if (date == null)
{
date = DateTime.Today;
}
ViewItemWeightCategory weight = addParams.Class.WeightCategories.FirstOrDefault(i => i.Identifier == NavigationManager.SelectedWeightCategoryIdentifier);
if (weight == null)
{
weight = addParams.Class.WeightCategories.First();
}
return(new AddGradeViewModel(parent)
{
State = addParams.IsInWhatIfMode ? OperationState.AddingWhatIf : OperationState.Adding,
Date = date.Value,
WeightCategories = addParams.Class.WeightCategories,
SelectedWeightCategory = weight
});
}
public async void Save()
{
try
{
if (!AreWeightsValid())
{
await new PortableMessageDialog(PowerPlannerResources.GetString("String_InvalidWeightCategoriesMessageBody"), PowerPlannerResources.GetString("String_InvalidWeightCategoriesMessageHeader")).ShowAsync();
return;
}
DataChanges changes = new DataChanges();
// Process weight category changes
List <EditingWeightCategoryViewModel> newWeights = new List <EditingWeightCategoryViewModel>(WeightCategories);
List <BaseViewItemMegaItem> lostGrades = new List <BaseViewItemMegaItem>();
//handle weights that were deleted
foreach (ViewItemWeightCategory existing in Class.WeightCategories)
{
//if that existing weight isn't in the new weights list
if (!newWeights.Any(i => i.Identifier == existing.Identifier))
{
//mark it for deletion
changes.DeleteItem(existing.Identifier);
//add all of its grades to the lost grades
lostGrades.AddRange(existing.Grades);
}
}
//if there aren't any weights, need to add the default All Grades
if (newWeights.Count == 0)
{
newWeights.Add(new EditingWeightCategoryViewModel()
{
Name = PowerPlannerResources.GetString("WeightCategory_AllGrades"),
Weight = 100
});
}
Guid firstCategory = newWeights.First().Identifier;
//strip away any existing weight categories that didn't change
foreach (EditingWeightCategoryViewModel newWeight in newWeights.ToArray())
{
ViewItemWeightCategory existing = Class.WeightCategories.FirstOrDefault(i => i.Identifier == newWeight.Identifier);
if (existing != null)
{
//if the name and/or value didn't change, we'll remove it from the main list
if (existing.Name.Equals(newWeight.Name) && existing.WeightValue == newWeight.Weight)
{
newWeights.Remove(newWeight);
}
}
}
//and now process the new/changed weights
foreach (EditingWeightCategoryViewModel changed in newWeights)
{
DataItemWeightCategory w;
ViewItemWeightCategory existing = Class.WeightCategories.FirstOrDefault(i => i.Identifier == changed.Identifier);
//if existing, serialize
if (existing != null)
{
w = new DataItemWeightCategory()
{
Identifier = existing.Identifier
}
}
;
else
{
w = new DataItemWeightCategory()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = Class.Identifier
};
//if we didn't have a first category yet
if (firstCategory == Guid.Empty)
{
firstCategory = w.Identifier;
}
}
w.Name = changed.Name;
w.WeightValue = changed.Weight;
changes.Add(w);
}
// And then move the lost grades into the first available weight category
foreach (var lostGrade in lostGrades.OfType <ViewItemGrade>())
{
DataItemGrade g = new DataItemGrade()
{
Identifier = lostGrade.Identifier
};
g.UpperIdentifier = firstCategory;
changes.Add(g);
}
foreach (var lostGrade in lostGrades.OfType <ViewItemTaskOrEvent>())
{
DataItemMegaItem g = new DataItemMegaItem()
{
Identifier = lostGrade.Identifier
};
g.WeightCategoryIdentifier = firstCategory;
changes.Add(g);
}
TryStartDataOperationAndThenNavigate(delegate
{
return(PowerPlannerApp.Current.SaveChanges(changes));
}, delegate
{
this.RemoveViewModel();
});
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
await new PortableMessageDialog("Error encountered while saving. Your error report has been sent to the developer.", "Error").ShowAsync();
}
}
private MyObservableList <BaseViewItemHomeworkExamGrade> SelectGrades(ViewItemWeightCategory weightCategory)
{
return(weightCategory.Grades);
}
public async void Save()
{
// First we block user interaction on checking if full version, since don't want to dismiss the UI
// before prompting that they need the full version (otherwise they'd lose data)
await TryHandleUserInteractionAsync("SaveCheckingIfAllowed", async (cancellationToken) =>
{
Guid identifierToIgnore = _editingGrade == null ? Guid.Empty : _editingGrade.Identifier;
// For free version, block assigning grade if number of graded items exceeds 5
if (SelectedWeightCategory != null &&
(_editingGrade == null || _editingGrade.GradeReceived == PowerPlannerSending.Grade.UNGRADED) &&
SelectedWeightCategory.Class.WeightCategories.SelectMany(i => i.Grades).Where(i => i.Identifier != identifierToIgnore && i.GradeReceived != PowerPlannerSending.Grade.UNGRADED).Count() >= 5 &&
!await PowerPlannerApp.Current.IsFullVersionAsync())
{
cancellationToken.ThrowIfCancellationRequested();
PowerPlannerApp.Current.PromptPurchase(PowerPlannerResources.GetString("MessageFreeGradesLimitReached"));
return;
}
// And then we perform the data operation which doesn't need any UI interaction blocks
TryStartDataOperationAndThenNavigate(async delegate
{
string name = Name;
if (name.Length == 0)
{
new PortableMessageDialog(PowerPlannerResources.GetString("String_NoNameMessageBody"), PowerPlannerResources.GetString("String_NoNameMessageHeader")).Show();
return;
}
ViewItemWeightCategory weightCategory = SelectedWeightCategory;
if (weightCategory == null)
{
new PortableMessageDialog(PowerPlannerResources.GetString("EditGradePage_MessageNoWeightCategoryBody"), PowerPlannerResources.GetString("EditGradePage_MessageNoWeightCategoryHeader")).Show();
return;
}
//// What If mode
if (State == OperationState.AddingWhatIf || State == OperationState.EditingWhatIf)
{
BaseViewItemHomeworkExamGrade whatIfGrade;
// New
if (_editingGrade == null)
{
whatIfGrade = new ViewItemGrade(null)
{
DateCreated = DateTime.UtcNow,
Updated = DateTime.UtcNow
}
}
;
// Existing
else
{
whatIfGrade = _editingGrade;
whatIfGrade.Updated = DateTime.UtcNow;
}
whatIfGrade.Name = name;
whatIfGrade.Details = Details;
whatIfGrade.Date = DateTime.SpecifyKind(Date, DateTimeKind.Utc).Date.Add(_originalDateOffset);
whatIfGrade.GradeReceived = GradeReceived;
whatIfGrade.GradeTotal = GradeTotal;
if (UsesIsDropped)
{
whatIfGrade.IsDropped = IsDropped;
}
whatIfGrade.WasChanged = true;
whatIfGrade.CanBeUsedForAchievingDesiredGrade = whatIfGrade.GradeReceived == PowerPlannerSending.Grade.UNGRADED;
if (whatIfGrade.WeightCategory != null)
{
whatIfGrade.WeightCategory.Remove(whatIfGrade);
}
weightCategory.Add(whatIfGrade);
weightCategory.Class.ResetDream();
}
else
{
BaseDataItemHomeworkExamGrade g;
if (State == OperationState.Adding)
{
g = new DataItemGrade()
{
Identifier = Guid.NewGuid()
}
}
;
else
{
g = _editingGrade.CreateBlankDataItem();
}
g.Name = name;
if (g is DataItemGrade)
{
g.UpperIdentifier = weightCategory.Identifier;
}
else if (g is DataItemMegaItem)
{
(g as DataItemMegaItem).WeightCategoryIdentifier = weightCategory.Identifier;
}
g.Details = Details;
g.Date = DateTime.SpecifyKind(Date, DateTimeKind.Utc).Date.Add(_originalDateOffset);
g.GradeReceived = GradeReceived;
g.GradeTotal = GradeTotal;
if (UsesIsDropped)
{
g.IsDropped = IsDropped;
}
DataChanges changes = new DataChanges();
changes.Add(g);
await PowerPlannerApp.Current.SaveChanges(changes);
// We don't cancel here since we need the following to occur, and removing the view model is fine regardless
}
NavigationManager.SetPreviousAddItemDate(Date);
NavigationManager.SelectedWeightCategoryIdentifier = weightCategory.Identifier;
}, delegate
{
_onSaved?.Invoke();
this.RemoveViewModel();
});
});
private MyObservableList <BaseViewItemMegaItem> SelectGrades(ViewItemWeightCategory weightCategory)
{
return(weightCategory.Grades);
}
