private async void SaveSection()
{
if (!IsValidInput())
{
DisplayAlert("Invalid input", "Cannot be empty.");
return;
}
var sectionsRealm = new Domain.Services.Realms.EvaluationSections();
var evaluationsRealm = new Domain.Services.Realms.Evaluations();
await sectionsRealm.WriteAsync(realm =>
{
var item = IsEditingExistingSection ? realm.Get(SectionLocalId) : realm.CreateObject();
item.Name = Name;
item.Body = Body;
item.Score = Score;
item.Evaluation = evaluationsRealm.Get(EvaluationLocalId);
item.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncPostsAndContinue();
await LeavePage();
}
private async Task HandleLogin()
{
var token = await RequestToken();
if (token != null)
{
// save token and continue
SaveContext(Email, token, true, null);
var currentContext = GetContext();
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncAllAndWait();
var membersRealm = new Domain.Services.Realms.Members();
var profile = GetCurrentUser().Profile;
var member = membersRealm.Get(x => x.Profile == profile);
currentContext.SchoolName = member.School.Name;
SaveContext(currentContext);
Application.Current.Properties["Context"] = JsonConvert.SerializeObject(currentContext);
App.LaunchMasterDetailPage?.Invoke(this, EventArgs.Empty);
}
else
{
DisplayAlert("Login failed", "Either wrong credentials or no such user.");
}
}
private async void SaveClass()
{
if (!IsValidInput())
{
DisplayAlert("Invalid input", "Cannot be empty.");
return;
}
var classesRealm = new Domain.Services.Realms.Classes();
await classesRealm.WriteAsync(realm =>
{
var classModel = IsNewClass ? realm.CreateObject() : realm.Get(ClassLocalId);
classModel.Name = ClassName;
classModel.Day = Days[DaysIndex];
var startTime = new DateTimeOffset(1, 1, 1, StartTime.Hours, StartTime.Minutes, StartTime.Seconds, TimeSpan.Zero);
classModel.StartTime = startTime.UtcDateTime.Date;
var endTime = new DateTimeOffset(1, 1, 1, EndTime.Hours, EndTime.Minutes, EndTime.Seconds, TimeSpan.Zero);
classModel.EndTime = endTime.UtcDateTime.Date;
classModel.School = GetCurrentSchool();
classModel.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncPostsAndContinue();
await Navigator.PopAsync(Navigation);
}
private void Initialize()
{
var contextCache = Domain.Services.Caches.Context.GetInstance();
object contextObject;
Current.Properties.TryGetValue("Context", out contextObject);
Domain.Objects.Context context = null;
if (contextObject != null)
{
context = JsonConvert.DeserializeObject <Domain.Objects.Context>((string)contextObject);
}
if (context != null)
{
contextCache.Replace("Context", context);
if (context.IsAuthenticated)
{
LoadMasterDetailPage();
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncAllAndContinue();
}
else
{
LoadLoginPage();
}
}
else
{
var newContext = new Domain.Objects.Context();
contextCache.Replace("Context", newContext);
LoadLoginPage();
}
}
private async void Join()
{
var currentContext = GetContext();
// get school by name
var schoolsRestService = new Domain.Services.Rest.Schools();
var postedSchool = await schoolsRestService.GetAsync(SchoolName, currentContext.AccessToken.Access_Token);
if (postedSchool == null)
{
return;
}
currentContext.SchoolName = SchoolName;
SaveContext(currentContext);
var savedSchool = await SaveSchool(postedSchool);
// get current profile
var profile = GetCurrentUser().Profile;
// post member
var member = await PostMember(savedSchool, profile);
// save member
await SaveMember(member, savedSchool, profile);
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncAllAndWait();
// navigate to master detail page for students
App.LaunchMasterDetailPage?.Invoke(this, EventArgs.Empty);
}
public async void HandleAttendance(string isAttendingStr)
{
var isAttending = bool.Parse(isAttendingStr);
var currentProfile = GetCurrentUser().Profile;
// the user has decided to change their attendance, so we first have to check if
// a record of their attendance exists for this particular class
AttendanceModel = AttendanceRealm.GetRealmResults()
.Where(x => x.Date == Date)
.FirstOrDefault(x => x.Profile == currentProfile);
var recordExists = AttendanceModel != null;
var attendanceLocalId = 0;
if (recordExists)
{
attendanceLocalId = AttendanceModel.LocalId;
}
await AttendanceRealm.WriteAsync(realm =>
{
var attendanceRecord = recordExists ? realm.Get(attendanceLocalId) : realm.CreateObject();
attendanceRecord.Class = ClassModel;
attendanceRecord.Date = Date.UtcDateTime.Date;
attendanceRecord.Profile = currentProfile;
attendanceRecord.IsAttending = isAttending;
attendanceRecord.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncPostsAndContinue();
GetAttendants();
}
private async void Save()
{
if (!IsValidInput())
{
DisplayAlert("Invalid input", "Cannot be empty.");
return;
}
var membersRealm = new Domain.Services.Realms.Members();
await EvaluationsRealm.WriteAsync(realm =>
{
var eval = IsEditingExistingEvaluation ? realm.Get(EvaluationLocalId) : realm.CreateObject();
eval.Name = Name;
if (!IsEditingExistingEvaluation)
{
eval.Member = membersRealm.Get(MemberLocalId);
}
eval.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncPostsAndContinue();
await LeavePage();
}
private async Task SaveExistingSchool()
{
var schoolsRealm = new Domain.Services.Realms.Schools();
var schoolLocalId = GetCurrentSchool().LocalId;
await schoolsRealm.WriteAsync(realm =>
{
var school = realm.Get(schoolLocalId);
var mapper = new Domain.Utilities.PropertyMapper();
mapper.Map <Domain.Models.School>(SchoolModel, school);
school.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncPostsAndWait();
await Navigator.PopAsync(Navigation);
}
private async Task SaveExistingProfile()
{
if (!Validate())
{
return;
}
var profilesRealm = new Domain.Services.Realms.Profiles();
var profileLocalId = GetCurrentUser().Profile.LocalId;
await profilesRealm.WriteAsync(realm =>
{
var profile = realm.Get(profileLocalId);
var mapper = new Domain.Utilities.PropertyMapper();
mapper.Map <Domain.Models.Profile>(ProfileModel, profile);
profile.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncPostsAndWait();
await Navigator.PopAsync(Navigation);
}
private async void Signout()
{
var accountService = new Domain.Services.Rest.Security.Account();
var logoutResult = await accountService.PostLogoutAsync(GetContext().AccessToken.Access_Token);
if (logoutResult.IsSuccessStatusCode)
{
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncPostsAndWait();
SaveContext(null, null, false, null);
var realm = Realm.GetInstance();
await realm.WriteAsync(tempRealm =>
{
tempRealm.RemoveAll();
});
Application.Current.Properties["Context"] = null;
App.LaunchLoginPage?.Invoke(this, EventArgs.Empty);
}
}
public async void HandleCanceledClass()
{
var canceledRealm = new Domain.Services.Realms.CanceledClasses();
var recordExists = CanceledModel != null;
var canceledLocalId = 0;
if (recordExists)
{
canceledLocalId = CanceledModel.LocalId;
}
await canceledRealm.WriteAsync(realm =>
{
var record = recordExists ? realm.Get(canceledLocalId) : realm.CreateObject();
record.Date = Date.UtcDateTime.Date;
record.IsCanceled = IsCanceled;
realm.Manage(record);
record.Class = ClassModel;
record.Synced = false;
});
var synchronizer = new Domain.Services.Sync.Synchronizer();
synchronizer.SyncPostsAndContinue();
}
private async void Launch(string pageName)
{
switch (pageName)
{
case "Calendar":
{
await Navigator.PushCalendarPageAsync(Navigation);
break;
}
case "Classes":
{
await Navigator.PushClassesPageAsync(Navigation);
break;
}
case "Students":
{
await Navigator.PushStudentsPageAsync(Navigation);
break;
}
case "Evaluations":
{
await Navigator.PushEvaluationsPageAsync(Navigation, GetCurrentUser().Profile.LocalId);
break;
}
case "Profile":
{
await Navigator.PushProfilePageAsync(Navigation, GetCurrentUser().Profile.LocalId);
break;
}
case "School":
{
await Navigator.PushSchoolPageAsync(Navigation);
break;
}
case "Signout":
{
var accountService = new Domain.Services.Rest.Security.Account();
var logoutResult = await accountService.PostLogoutAsync(GetContext().AccessToken.Access_Token);
if (logoutResult.IsSuccessStatusCode)
{
var synchronizer = new Domain.Services.Sync.Synchronizer();
await synchronizer.SyncPostsAndWait();
SaveContext(null, null, false);
var config = Realm.GetInstance().Config;
Realm.DeleteRealm(config);
Application.Current.Properties["Context"] = null;
App.LaunchLoginPage?.Invoke(this, EventArgs.Empty);
}
break;
}
}
;
}
