// Class Methods
/// <summary>
/// Gets a list of Addresses, and updates the list with Database info
/// </summary>
/// <param name="addresses"></param>
public void fillAddressDropdown(List <Address> addresses)
{
using (var conn = new MySqlConnection(connecterString))
{
MySqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "SELECT * FROM address";
MySqlDataReader reader1 = DataChanges.GetMySqlReader(conn, cmd.CommandText);
//Use this to see if the country exists, and to count the number of countries
while (reader1.Read())
{
var AddressId = (int)reader1["addressId"];
var Address1 = reader1["address"].ToString();
var Address2 = reader1["address2"].ToString();
var CityId = (int)reader1["cityId"];
var PostalCode = reader1["postalCode"].ToString();
var Phone = reader1["phone"].ToString();
var CreatedBy = reader1["createdBy"].ToString();
var LastUpdateBy = reader1["lastUpdateBy"].ToString();
Address myAddress = new Address(AddressId, Address1, Address2, CityId, PostalCode, Phone, CreatedBy, LastUpdateBy);
addresses.Add(myAddress);
}
conn.Close();
cmd.Connection.Close();
foreach (var addr in addresses)
{
// Populate a new row on the combobox
comboBox_AddressPopulate.Items.Add(addr.address.ToString() + ", " + addr.address2.ToString());
// fill the city object for the address object
addr.cityObject = new City(addr.cityId, loggedInUser, conn);
}
//Set the list equal to the class list
Addresses = addresses;
}
}
/// <summary>
/// Notifies the data change.
/// </summary>
public void NotifyDataChange()
{
DataChanges.OnNext(new DataChange()
{
SizeChanged = false
});
}
public async System.Threading.Tasks.Task TestDeletingClassSchedule()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemSchedule()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = base.CurrentClassId,
StartTime = new DateTime(2015, 1, 1, 8, 00, 00, DateTimeKind.Utc),
EndTime = new DateTime(2015, 1, 1, 8, 50, 00, DateTimeKind.Utc),
Room = "Modern Languages 201",
ScheduleWeek = Schedule.Week.BothWeeks,
ScheduleType = Schedule.Type.Normal,
DayOfWeek = DayOfWeek.Monday
});
await DataStore.ProcessLocalChanges(changes);
var viewModel = await ViewModelClass.LoadAsync(base.LocalAccountId, base.CurrentClassId, new DateTime(2015, 1, 1, 0, 0, 0, DateTimeKind.Utc));
Assert.AreEqual(1, viewModel.Class.Schedules.Count);
var schedule = viewModel.Class.Schedules[0];
changes = new DataChanges();
changes.DeleteItem(schedule.Identifier);
await DataStore.ProcessLocalChanges(changes);
viewModel = await ViewModelClass.LoadAsync(base.LocalAccountId, base.CurrentClassId, new DateTime(2015, 1, 1, 0, 0, 0, DateTimeKind.Utc));
Assert.AreEqual(0, viewModel.Class.Schedules.Count);
}
private async void Save()
{
try
{
IsEnabled = false;
var changes = new DataChanges();
// Class changes
var c = new DataItemClass()
{
Identifier = Class.Identifier,
DoesRoundGradesUp = RoundGradesUp
};
changes.Add(c);
await TryHandleUserInteractionAsync("Save", async delegate
{
await PowerPlannerApp.Current.SaveChanges(changes);
}, "Failed to save. Your error has been reported.");
}
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();
}
finally
{
IsEnabled = true;
}
}
protected override async Task InitializeAfterAccount()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Freshman"
});
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Sophomore"
});
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Junior"
});
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Senior"
});
await DataStore.ProcessLocalChanges(changes);
await InitializeAfterYears();
}
public async Task TestAdding_DateCreated()
{
DataChanges changes = new DataChanges();
// Add multiple at once
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Freshman"
});
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Sophomore"
});
await DataStore.ProcessLocalChanges(changes);
ViewModelYearsAndSemesters viewModel = await ViewModelYearsAndSemesters.LoadAsync(LocalAccountId);
var freshman = viewModel.School.Years[0];
var sophomore = viewModel.School.Years[1];
Assert.AreEqual("Freshman", freshman.Name);
Assert.AreEqual("Sophomore", sophomore.Name);
// Make sure the second item is 1 tick after the first
Assert.AreEqual(freshman.DateCreated.AddTicks(1), sophomore.DateCreated);
}
public void SetPercentComplete(double percentComplete)
{
ViewItemHomework homework = Item as ViewItemHomework;
if (homework == null || homework.PercentComplete == percentComplete)
{
return;
}
TryStartDataOperationAndThenNavigate(delegate
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemMegaItem()
{
Identifier = homework.Identifier,
PercentComplete = percentComplete
});
return(PowerPlannerApp.Current.SaveChanges(changes));
}, delegate
{
// Go back immediately before
if (percentComplete == 1)
{
this.GoBack();
}
});
}
public void DropGrade()
{
TryStartDataOperationAndThenNavigate(async delegate
{
if (IsInWhatIfMode)
{
Grade.IsDropped = true;
Grade.WasChanged = true;
Grade.WeightCategory.Class.ResetDream();
}
else
{
var g = Grade.CreateBlankDataItem();
g.IsDropped = true;
DataChanges changes = new DataChanges();
changes.Add(g);
await PowerPlannerApp.Current.SaveChanges(changes);
}
}, delegate
{
this.RemoveViewModel();
});
}
public async Task TestViewModelCalendar_EdgeCase()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemHomework()
{
Name = "New Year 2016",
Date = new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Identifier = Guid.NewGuid(),
UpperIdentifier = base.CurrentClassId,
Details = ""
});
await base.DataStore.ProcessLocalChanges(changes);
// TODO
//var viewModel = await ViewModelCalendar.LoadAsync(base.LocalAccountId, base.CurrentSemesterId);
//Assert.AreEqual(0, viewModel.Items.Count, "Should start empty");
//await viewModel.ApplyFilterAsync(new DateTime(2015, 10, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc));
//Assert.AreEqual(1, viewModel.Items.Count, "After first filter");
//await viewModel.ApplyFilterAsync(new DateTime(2015, 11, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2016, 2, 1, 0, 0, 0, DateTimeKind.Utc));
//Assert.AreEqual(1, viewModel.Items.Count, "After second filter");
}
public async Task TestAddingClass_Defaults()
{
DataItemClass c = new DataItemClass()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = base.CurrentSemesterId,
Credits = 3,
Name = "Math",
Details = "",
RawColor = ColorTools.GetArray(Colors.Red, 3)
};
DataChanges changes = new DataChanges();
changes.Add(c);
await base.DataStore.ProcessLocalChanges(changes);
var viewModel = await ViewModelClass.LoadAsync(base.LocalAccountId, c.Identifier, DateTime.Today);
var viewClass = viewModel.Class;
Assert.AreEqual("Math", viewClass.Name);
Assert.AreEqual(3, viewClass.Credits);
Assert.AreEqual("", viewClass.Details);
Assert.AreEqual(Colors.Red, viewClass.Color);
}
protected override void BeginWriteTransaction(DataChanges changes)
{
if (changes == null || changes.Shape == null)
{
return;
}
if (changes.Shape.Length != Rank)
{
throw new Exception("Changes has wrong shape");
}
copyArray = null;
recentChanges = changes;
getRecentDataCalled = false;
bool needEnlarge = false;
int n = Rank;
int[] shape = array.GetShape();
for (int i = 0; i < n; i++)
{
if (changes.Shape[i] > shape[i])
{
needEnlarge = true;
break;
}
}
if (needEnlarge)
{
copyArray = new ArrayWrapper(n, TypeOfData);
copyArray.Data = Array.CreateInstance(copyArray.DataType, changes.Shape);
}
}
public void Delete()
{
TryStartDataOperationAndThenNavigate(async delegate
{
if (IsInWhatIfMode)
{
Grade.WeightCategory.Remove(Grade);
Grade.WeightCategory.Class.ResetDream();
}
else
{
// Tasks/events don't actually get deleted, just excluded from grades
if (Grade is ViewItemTaskOrEvent taskOrEvent)
{
var dataItem = taskOrEvent.CreateBlankDataItem();
dataItem.WeightCategoryIdentifier = PowerPlannerSending.BaseHomeworkExam.WEIGHT_CATEGORY_EXCLUDED;
DataChanges changes = new DataChanges();
changes.Add(dataItem);
await PowerPlannerApp.Current.SaveChanges(changes);
}
else
{
await MainScreenViewModel.DeleteItem(Grade);
}
}
}, delegate
protected override void CommitWrite(DataChanges proposedChanges)
{
if (proposedChanges != null && proposedChanges.HasData)
{
if (getRecentDataCalled)
{
array = copyArray;
}
else
{
int n = proposedChanges.Data.Count;
if (copyArray != null)
{
if (array.Data != null)
{
copyArray.PutData(null, array.Data);
}
array = copyArray;
}
for (int i = 0; i < n; i++)
{
DataPiece piece = proposedChanges.Data[i];
array.PutData(piece.Origin, piece.Data);
}
}
}
recentChanges = null;
getRecentDataCalled = false;
}
public async Task TestAddingSemester()
{
ViewModelYearsAndSemesters viewModel = await ViewModelYearsAndSemesters.LoadAsync(LocalAccountId);
var years = viewModel.School.Years;
var freshman = viewModel.School.Years[0];
var sophomore = viewModel.School.Years[1];
var junior = viewModel.School.Years[2];
var senior = viewModel.School.Years[3];
DataChanges changes = new DataChanges();
changes.Add(new DataItemSemester()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = freshman.Identifier,
Name = "Fall (Freshman)"
});
await DataStore.ProcessLocalChanges(changes);
Assert.AreEqual(1, freshman.Semesters.Count);
Assert.AreEqual(freshman.Identifier, freshman.Semesters.First().Year.Identifier);
Assert.AreEqual("Fall (Freshman)", freshman.Semesters.First().Name);
}
public async void UndropGrade()
{
try
{
if (IsInWhatIfMode)
{
Grade.IsDropped = false;
Grade.WasChanged = true;
Grade.WeightCategory.Class.ResetDream();
}
else
{
var g = Grade.CreateBlankDataItem();
g.IsDropped = false;
DataChanges changes = new DataChanges();
changes.Add(g);
await PowerPlannerApp.Current.SaveChanges(changes);
}
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public async Task DeleteItem(Guid identifier)
{
DataChanges changes = new DataChanges();
changes.DeleteItem(identifier);
await PowerPlannerApp.Current.SaveChanges(changes);
}
public async Task TestCascadeDeleteYear()
{
Guid freshmanId = Guid.NewGuid();
Guid tempId;
DataChanges changes = new DataChanges();
changes.Add(new DataItemYear()
{
Identifier = freshmanId,
Name = "Freshman"
});
changes.Add(new DataItemSemester()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = changes.EditedItems.OfType <DataItemYear>().First().Identifier,
Name = "Fall"
});
changes.Add(new DataItemSemester()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = changes.EditedItems.OfType <DataItemYear>().First().Identifier,
Name = "Spring"
});
changes.Add(new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = "Sophomore"
});
changes.Add(new DataItemSemester()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = changes.EditedItems.OfType <DataItemYear>().First(i => i.Name.Equals("Sophomore")).Identifier,
Name = "Fall - Sophomore"
});
await DataStore.ProcessLocalChanges(changes);
Assert.AreEqual(2, DataStore.TableYears.Count(), "Database count of years incorrect");
Assert.AreEqual(3, DataStore.TableSemesters.Count(), "Database count of semesters incorrect");
changes = new DataChanges();
changes.DeleteItem(freshmanId);
await DataStore.ProcessLocalChanges(changes);
Assert.AreEqual(1, DataStore.TableYears.Count(), "Database count of years incorrect");
Assert.AreEqual(1, DataStore.TableSemesters.Count(), "Database count of semesters incorrect");
}
/// <summary>
/// The method is called at the commit stage of the variable.
/// </summary>
/// <remarks>
/// <see cref="DataAccessVariable{DataType}"/>
/// closes a write-transaction thus confirming its success.
/// </remarks>
internal protected override void OnCommit(Variable.Changes proposedChanges)
{
/* Committing written data */
DataChanges dataChanges = proposedChanges as DataChanges;
if (dataChanges != null && dataChanges.HasData)
{
CommitWrite(dataChanges);
}
writeTransactionOpened = false;
}
/// <summary>
/// Loads all the lists and variables needed to create reports
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Frm_Reports_Load(object sender, EventArgs e)
{
comboBox_SelectReport.Items.Add(reportAppointmentMonthOption);
comboBox_SelectReport.Items.Add(reportConsultantScheduleOption);
comboBox_SelectReport.Items.Add(reportCustomerAppointmentsOption);
//Load all appointments into Lists to be able to search them quickly once this loads
using (var conn = new MySqlConnection(connecterString))
{
string getAppointments = "SELECT * FROM appointment";
var reader = DataChanges.GetMySqlReader(conn, getAppointments);
while (reader.Read())
{
//Fill Appointment Object Minus the Customer object
Appointment appointment = new Appointment();
appointment.appointmentId = (int)reader["appointmentId"];
appointment.customerId = (int)reader["customerId"];
appointment.title = reader["title"].ToString();
appointment.description = reader["description"].ToString();
appointment.location = reader["location"].ToString();
appointment.contact = reader["contact"].ToString();
appointment.start = Convert.ToDateTime(reader["start"]);
appointment.end = Convert.ToDateTime(reader["end"]);
appointment.createDate = Convert.ToDateTime(reader["createDate"]);
appointment.createdBy = reader["createdBy"].ToString();
appointment.lastUpdate = Convert.ToDateTime(reader["lastUpdate"]);
appointment.lastUpdateBy = reader["lastUpdateBy"].ToString();
appointment.type = reader["appointmentType"].ToString();
appointment.userId = (int)reader["userId"];
//Add Appointment to list of Appointments one by one
appointments.Add(appointment);
}
reader.Close();
foreach (var appointment in appointments)
{
appointment.customerObject = customers.Where(i => i.customerID == appointment.customerId).First();
}
//Load all Users into a list to be able to search those quickly
string getUsersQuery = "SELECT * FROM user";
var usersReader = DataChanges.GetMySqlReader(conn, getUsersQuery);
while (usersReader.Read())
{
User readUser = new User();
readUser.userId = (int)usersReader["userId"];
readUser.userName = usersReader["userName"].ToString();
users.Add(readUser);
}
usersReader.Close();
}
//Load all Customer Names and ID's (This is being done in Main Form when this form is created)
}
private void FlagFieldAsChanged(string fieldName, object previousValue)
{
if (fieldName.Equals("SuppressErrorNotification", StringComparison.OrdinalIgnoreCase))
{
return;
}
if (!DataChanges.ContainsKey(fieldName))
{
DataChanges.Add(fieldName, previousValue);
HasUnsavedChanges = true;
}
}
protected override async Task InitializeAfterSemesters()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemClass()
{
Credits = 3,
Details = "Some details about Math class",
Identifier = Guid.NewGuid(),
Name = "Math",
RawColor = ColorTools.GetArray(Colors.Blue, 3),
UpperIdentifier = CurrentSemesterId
});
CurrentClassId = Guid.NewGuid();
changes.Add(new DataItemClass()
{
Name = "English",
Details = "The class where you write essays in.",
Identifier = CurrentClassId,
Credits = 4,
RawColor = ColorTools.GetArray(Colors.Red, 3),
UpperIdentifier = CurrentSemesterId
});
changes.Add(new DataItemClass()
{
Name = "Spanish",
Details = "Learn a foreign language",
Identifier = Guid.NewGuid(),
Credits = 4,
RawColor = ColorTools.GetArray(Colors.Green, 3),
UpperIdentifier = base.CurrentSemesterId
});
changes.Add(new DataItemClass()
{
Name = "Science",
Details = "Perform experiments",
Identifier = Guid.NewGuid(),
Credits = 4,
RawColor = ColorTools.GetArray(Colors.Purple, 3),
UpperIdentifier = base.CurrentSemesterId
});
await DataStore.ProcessLocalChanges(changes);
}
public async Task TestViewModelCalendar_Normal()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemHomework()
{
Name = "New Year 2016",
Date = new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Identifier = Guid.NewGuid(),
UpperIdentifier = base.CurrentClassId,
Details = ""
});
changes.Add(new DataItemHomework()
{
Identifier = Guid.NewGuid(),
Name = "Birthday 2015",
Date = new DateTime(2015, 9, 25, 0, 0, 0, DateTimeKind.Utc),
Details = "Congrats!",
UpperIdentifier = base.CurrentClassId
});
changes.Add(new DataItemHomework()
{
Identifier = Guid.NewGuid(),
Name = "Afterparty 2015",
Date = new DateTime(2015, 9, 25, 0, 0, 0, DateTimeKind.Utc),
Details = "Celebrate!",
UpperIdentifier = base.CurrentClassId
});
await base.DataStore.ProcessLocalChanges(changes);
// TODO: Needs updating
Assert.Fail("Needs updating");
//var viewModel = await ViewModelCalendar.LoadAsync(base.LocalAccountId, base.CurrentSemesterId);
//Assert.AreEqual(0, viewModel.Items.Count, "Should start empty");
//await viewModel.ApplyFilterAsync(new DateTime(2015, 7, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2015, 11, 1, 0, 0, 0, DateTimeKind.Utc));
//Assert.AreEqual(2, viewModel.Items.Count, "After first filter");
//Assert.IsTrue(viewModel.Items.Any(i => i.Name.Equals("Birthday 2015")));
//Assert.IsTrue(viewModel.Items.Any(i => i.Name.Equals("Afterparty 2015")));
}
public void TestHomeworkExamSortingAll()
{
DataChanges changes = new DataChanges();
changes.Add(new DataItemExam()
{
Name = "Second item",
Date = new DateTime(2015, 1, 2, 0, 0, 0, DateTimeKind.Utc),
UpperIdentifier = base.CurrentClassId
});
changes.Add(new DataItemHomework()
{
Name = "First item",
Date = new DateTime(2015, 1, 1, 0, 0, 0, DateTimeKind.Utc),
UpperIdentifier = base.CurrentClassId
});
}
public static async System.Threading.Tasks.Task <AccountDataItem> CreateAndInitializeAccountAsync(string username, string localToken, string token, long accountId, int deviceId)
{
var account = await CreateAccountHelper.CreateAccountLocally(username, localToken, token, accountId, deviceId, needsInitialSync : false);
if (account != null)
{
AccountsManager.SetLastLoginIdentifier(account.LocalAccountId);
// Add the default year/semester
try
{
DataItemYear year = new DataItemYear()
{
Identifier = Guid.NewGuid(),
Name = PowerPlannerResources.GetString("DummyFirstYear")
};
DataItemSemester semester = new DataItemSemester()
{
Identifier = Guid.NewGuid(),
UpperIdentifier = year.Identifier,
Name = PowerPlannerResources.GetString("DummyFirstSemester")
};
DataChanges changes = new DataChanges();
changes.Add(year);
changes.Add(semester);
await PowerPlannerApp.Current.SaveChanges(account, changes);
await account.SetCurrentSemesterAsync(semester.Identifier);
NavigationManager.MainMenuSelection = NavigationManager.MainMenuSelections.Schedule;
return(account);
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
return(null);
}
public void Save()
{
TryStartDataOperationAndThenNavigate(delegate
{
string details = Details.Trim();
DataItemClass c = new DataItemClass()
{
Identifier = Class.Identifier,
Details = details
};
DataChanges editChanges = new DataChanges();
editChanges.Add(c);
return(PowerPlannerApp.Current.SaveChanges(editChanges));
}, delegate
{
this.GoBack();
});
}
public async void Save()
{
try
{
if (!AreScalesValid())
{
await new PortableMessageDialog(PowerPlannerResources.GetString("String_InvalidGradeScalesMessageBody"), PowerPlannerResources.GetString("String_InvalidGradeScalesMessageHeader")).ShowAsync();
return;
}
GradeScale[] newScales = GradeScales.ToArray();
DataChanges changes = new DataChanges();
// Class changes
{
var c = new DataItemClass()
{
Identifier = Class.Identifier
};
c.SetGradeScales(newScales);
changes.Add(c);
}
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();
}
}
public void Save()
{
TryStartDataOperationAndThenNavigate(delegate
{
DataChanges changes = new DataChanges();
// Class changes
var c = new DataItemClass()
{
Identifier = Class.Identifier,
PassingGrade = PassingGrade / 100
};
changes.Add(c);
return(PowerPlannerApp.Current.SaveChanges(changes));
}, delegate
{
this.RemoveViewModel();
});
}
public async Task MoveItem(BaseViewItemHomeworkExam item, DateTime toDate)
{
try
{
if (item.Date.Date == toDate.Date)
{
return;
}
DataChanges changes = new DataChanges();
var editedDataItem = item.CreateBlankDataItem();
editedDataItem.Date = DateTime.SpecifyKind(toDate.Date.Add(item.Date.TimeOfDay), DateTimeKind.Utc);
changes.Add(editedDataItem);
await PowerPlannerApp.Current.SaveChanges(changes);
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
/// <summary>
/// The method is called at the precommit stage of the variable.
/// </summary>
/// <remarks>
/// <see cref="DataAccessVariable{DataType}"/> opens a write-transaction and actually updates the related storage with
/// accumulated changes.
/// </remarks>
internal protected override void OnPrecommit(Variable.Changes proposedChanges)
{
/* Changing state of the variable */
DataChanges dataChanges = proposedChanges as DataChanges;
if (dataChanges != null && dataChanges.HasData)
{
// Writing data
BeginWriteTransaction(dataChanges);
writeTransactionOpened = true;
if (dataChanges.Data != null)
{
int n = dataChanges.Data.Count;
for (int i = 0; i < n; i++)
{
DataPiece piece = dataChanges.Data[i];
WriteData(piece.Origin, piece.Data);
}
}
}
}
public void Save()
{
TryStartDataOperationAndThenNavigate(async delegate
{
string name = Name;
if (string.IsNullOrWhiteSpace(name))
{
new PortableMessageDialog(PowerPlannerResources.GetString("AddYearPage_MessageNoName_Body"), PowerPlannerResources.GetString("AddYearPage_MessageNoName_Title")).Show();
return;
}
DataItemYear year;
if (YearToEdit != null)
{
year = new DataItemYear()
{
Identifier = YearToEdit.Identifier
}
}
;
else
{
year = new DataItemYear()
{
Identifier = Guid.NewGuid()
}
};
year.Name = name;
DataChanges changes = new DataChanges();
changes.Add(year);
await PowerPlannerApp.Current.SaveChanges(changes);
}, delegate
