public static WorkoutTemplate CreateWorkoutTemplateExercisesDTO(ObservableCollection<ExerciseViewModel> exercises, WorkoutTemplate template)
{
WorkoutTemplate returnValue = new WorkoutTemplate ();
returnValue.GymID = template.GymID;
returnValue.TemplateName = template.TemplateName;
returnValue.TemplateDescription = template.TemplateDescription;
returnValue.TemplateImageName = "skinandbones.png";
returnValue.LastUpdatedContext = "MobileFit_Coach";
returnValue.WorkoutTemplateExercises = new List<WorkoutTemplateExercise> ();
int sequence = 1;
foreach (ExerciseViewModel exerciseViewModel in exercises) {
WorkoutTemplateExercise workoutTemplate = new WorkoutTemplateExercise ();
workoutTemplate.ExerciseID = exerciseViewModel.Exercise.ExerciseID;
workoutTemplate.TargetSets = exerciseViewModel.Sets;
workoutTemplate.TargetReps = exerciseViewModel.Reps;
workoutTemplate.TargetDurationMin = exerciseViewModel.Duration;
//workoutTemplate.TargetHRMin = exerciseViewModel.TargetHRMin;
//workoutTemplate.TargetHRMax = exerciseViewModel.TargetHRMax;
workoutTemplate.LastUpdatedContext = "MobileFit_Coach";
workoutTemplate.ExerciseSequence = sequence++;
returnValue.WorkoutTemplateExercises.Add (workoutTemplate);
}
return returnValue;
}
public async static Task AddModifyTemplate(WorkoutTemplate workoutTemplate)
{
var db = DependencyService.Get<ISQLite>().GetAsyncConnection();
await db.CreateTableAsync<WorkoutTemplate>();
if (workoutTemplate.Id == 0)
{
await db.InsertAsync(workoutTemplate);
}
else {
await db.UpdateAsync(workoutTemplate);
}
}
public async static Task<WorkoutTemplate> CreateTemplate(int gymID, String templateName, String templateDescription)
{
WorkoutTemplate template = new WorkoutTemplate();
template = new WorkoutTemplate();
template.TemplateName = templateName;
template.TemplateDescription = templateDescription;
template.GymID = gymID;
var db = DependencyService.Get<ISQLite>().GetAsyncConnection();
await db.CreateTableAsync<WorkoutTemplate>();
await db.InsertAsync(template);
return template;
}
public static async Task<UserExercisesUpdateExerciseResponseDTO> CreateTemplateWithAssignment(ObservableCollection<ExerciseViewModel> exercises, WorkoutTemplate template, int profileID, bool logFeedback)
{
var dto = UserWorkoutTemplateMappingsDTOCreator.CreateWorkoutTemplateExercisesDTO(exercises, template, profileID, logFeedback);
string uri = "CreateTemplateWithAssignment";
string rawJSON = JsonConvert.SerializeObject(dto);
string stringResponse = await BaseCoachServices.ServiceAPI.Post(uri, rawJSON);
if (stringResponse == "401")
{
if (await TokenManager.RefreshToken())
{
stringResponse = await BaseCoachServices.ServiceAPI.Post(uri, rawJSON);
}
}
return JsonConvert.DeserializeObject<UserExercisesUpdateExerciseResponseDTO>(stringResponse);
}
public async static Task SaveTemplateRecordAndIncrementFailedCount(WorkoutTemplate template)
{
template.SyncAttempts += 1;
var db = DependencyService.Get<ISQLite>().GetAsyncConnection();
await db.CreateTableAsync<WorkoutTemplate>();
var currentRecord = await db.Table<WorkoutTemplate>().Where(row => row.Id == template.Id).FirstOrDefaultAsync();
if (currentRecord != null && currentRecord.Id != 0)
{
await db.UpdateAsync(template);
}
else {
await db.InsertAsync(template);
}
}
public async static Task SubmitWorkout(ObservableCollection<ExerciseViewModel> exercises, WorkoutTemplate template, int profileID, bool logFeedback = false, int localFeedbackSubmissionID = 0, int localUserExerciseGroupID = 0)
{
Boolean isMemberAttached = false;
if (profileID != 0)
{
isMemberAttached = true;
}
if(isMemberAttached)
{
var dtoResponse = await CoachServices.CreateTemplateWithAssignment(exercises,template,profileID, logFeedback);
if (dtoResponse.TemplateID != 0) {
await WorkoutTemplateDAL.AddServerTemplateID (template.GymID, template.Id, dtoResponse.TemplateID);
await UserDAL.AddServerTemplateIDLocal (profileID, dtoResponse.TemplateID);
} else {
//Increment failed server sync count
template.SyncAttempts++;
await WorkoutTemplateDAL.AddModifyTemplate (template);
}
if (logFeedback && localFeedbackSubmissionID !=0) {
FeedbackSubmission feedbackSumbission = await FeedbackSubmissionDAL.GetFeedbackSubmissionByLocalID (localFeedbackSubmissionID);
feedbackSumbission.ServerFeedbackSubmissionID = dtoResponse.WorkoutID;
await FeedbackSubmissionDAL.AddModifyFeedbackSubmission (feedbackSumbission);
}
if(dtoResponse.UserWorkoutGroupID != 0){
if(localUserExerciseGroupID != 0){
UserExerciseGroup userExerciseGroup = await UserExerciseGroupDAL.GetUserExerciseGroupByLocalExerciseGroupID (localUserExerciseGroupID);
userExerciseGroup.UserWorkoutGroupID = dtoResponse.UserWorkoutGroupID;
await UserExerciseGroupDAL.AddModify (userExerciseGroup);
}
}
}
else
{
int serverTemplateID = await CoachServices.CreateTemplate(exercises,template);
if(serverTemplateID != 0){
await WorkoutTemplateDAL.AddServerTemplateID (template.GymID, template.Id, serverTemplateID);
}
}
}
public static async Task<int> CreateTemplate(ObservableCollection<ExerciseViewModel> exercises, WorkoutTemplate template)
{
var dto = WorkoutTemplateExercisesCreator.CreateWorkoutTemplateExercisesDTO(exercises, template);
string uri = "WorkoutTemplates";
int serverTemplateID = 0;
try
{
string rawJSON = JsonConvert.SerializeObject(dto);
string stringResponse = await BaseCoachServices.ServiceAPI.Post(uri, rawJSON);
if (stringResponse == "401")
{
if (await TokenManager.RefreshToken())
{
stringResponse = await BaseCoachServices.ServiceAPI.Post(uri, rawJSON);
}
}
string[] splitSingleQuoteFirstSplit = stringResponse.Split(' ');
string templateIDKey = splitSingleQuoteFirstSplit[0];
if (templateIDKey == "\"TemplateID")
{
string templateIDString = splitSingleQuoteFirstSplit[1];
serverTemplateID = int.Parse(templateIDString);
}
else {
throw new Exception("Not expected response in '" + uri + "' web service method)");
}
}
catch (Exception e)
{
Insights.Report(e);
}
return serverTemplateID;
}
private async Task WriteToRepository (Entry templateNameEntry, Editor templateDescriptionEntry, Boolean writeUserMapping)
{
activityIndicator.IsRunning = true;
activityIndicator.IsVisible = true;
submitButton.IsEnabled = false;
cancel2Button.IsEnabled = false;
WorkoutTemplate workoutTemplate = new WorkoutTemplate ();
if (allSwitch.IsToggled) {
//Create template record in the local database
TemplateViewModel simpleTemplate = App.WorkoutCreatorContext.Template;
simpleTemplate.TemplateName = templateNameEntry.Text;
simpleTemplate.TemplateDescription = templateDescriptionEntry.Text;
workoutTemplate = await WorkoutTemplateDAL.CreateTemplate (App.WorkoutCreatorContext.StaffMember.GymID, simpleTemplate.TemplateName, simpleTemplate.TemplateDescription);
//Map the exercises to the template record
await WorkoutTemplateMappingDAL.CreateWorkoutTemplateMapping (workoutTemplate.Id, App.WorkoutCreatorContext.Exercises);
}
int gymID = App.WorkoutCreatorContext.StaffMember.GymID;
int profileID = 0;
if (_selectedUser != null) {
profileID = _selectedUser.ProfileID;
}
//Will be used if writing feedback for user
int localFeedbackID = 0;
int localUserExerciseGroupID = 0;
//Only save user mapping and userworkouttemplatemapping if a user was selected and matches text entry
if (writeUserMapping) {
if (templateSwitch.IsToggled && completedWorkoutsSwitch.IsToggled) {
//create local template and map to user
await UserDAL.AssignUserTemplate (_selectedUser.ProfileID, workoutTemplate.Id);
//Create userExerciseGroup in local database
var userExerciseGroup = CreateUserExerciseGroup (workoutTemplate);
await UserExerciseGroupDAL.AddModify (userExerciseGroup);
localUserExerciseGroupID = userExerciseGroup.Id;
await UserWorkoutTemplateMappingDAL.CreateUserWorkoutTemplateMapping (profileID, gymID, App.WorkoutCreatorContext.Exercises, userExerciseGroup.Id);
//Create local feedback submission records (will initially be dirty)
var feedbackSubmission = await FeedbackSubmissionDAL.CreateFeedbackSubmission (gymID, profileID);
localFeedbackID = feedbackSubmission.Id;
await FeedbackSubmissionExercisesDAL.CreateFeedbackSubmissionExercises (feedbackSubmission.Id, profileID, gymID, App.WorkoutCreatorContext.Exercises);
}
if (!templateSwitch.IsToggled && completedWorkoutsSwitch.IsToggled) {
//Create local feedback submission records (will initially be dirty)
var feedbackSubmission = await FeedbackSubmissionDAL.CreateFeedbackSubmission (gymID, profileID);
localFeedbackID = feedbackSubmission.Id;
await FeedbackSubmissionExercisesDAL.CreateFeedbackSubmissionExercises (feedbackSubmission.Id, profileID, gymID, App.WorkoutCreatorContext.Exercises);
}
if (templateSwitch.IsToggled && !completedWorkoutsSwitch.IsToggled) {
//Assign local template to the user
await UserDAL.AssignUserTemplate (profileID, workoutTemplate.Id);
//Create userExerciseGroup in local database
var userExerciseGroup = CreateUserExerciseGroup (workoutTemplate);
await UserExerciseGroupDAL.AddModify (userExerciseGroup);
localUserExerciseGroupID = userExerciseGroup.Id;
//Create the user exercise mapping in the local database
await UserWorkoutTemplateMappingDAL.CreateUserWorkoutTemplateMapping (profileID, gymID, App.WorkoutCreatorContext.Exercises, userExerciseGroup.Id);
}
}
//Send template to the service
//If need to create template and submit feedback for the member
if (memberSwitch.IsToggled && templateSwitch.IsToggled && completedWorkoutsSwitch.IsToggled && profileID != 0) {
await WorkoutTemplateMappingDAL.SubmitWorkout (App.WorkoutCreatorContext.Exercises, workoutTemplate, profileID, true, localFeedbackID, localUserExerciseGroupID);
//Send message to primaryoptionspage to check weather or not the feedbackoutbox button needs to be dispayed
MessagingCenter.Send<ModalWorkoutCreationPage> (this, "Check for dirty feedback");
} else {
//Can only store server feedback id in the local database if we have a local feedback id to map to
if (memberSwitch.IsToggled && !templateSwitch.IsToggled && completedWorkoutsSwitch.IsToggled && profileID != 0 && localFeedbackID != 0) {
await FeedbackSubmissionExercisesDAL.SubmitMemberFeedbackToServer (App.WorkoutCreatorContext.Exercises, profileID,
App.WorkoutCreatorContext.StaffMember.GymID, localFeedbackID);
//Send message to primaryoptionspage to check weather or not the feedbackoutbox button needs to be dispayed
MessagingCenter.Send<ModalWorkoutCreationPage> (this, "Check for dirty feedback");
} else {
//If need to create template and assign to member, but not submit feedback for the member
if (memberSwitch.IsToggled && templateSwitch.IsToggled && !completedWorkoutsSwitch.IsToggled && profileID != 0) {
await WorkoutTemplateMappingDAL.SubmitWorkout (App.WorkoutCreatorContext.Exercises, workoutTemplate, profileID, false, 0, localUserExerciseGroupID);
} else {
//If want to create general template (profileid = 0)
if (allSwitch.IsToggled && !memberSwitch.IsToggled) {
await WorkoutTemplateMappingDAL.SubmitWorkout (App.WorkoutCreatorContext.Exercises, workoutTemplate, 0);
}
}
}
}
App.WorkoutCreatorContext.RemoveTemplateAndExercises ();
//Uses session tracking
Insights.Track ("Created template", new Dictionary<string, string> () {
{ "template", workoutTemplate.TemplateName },
{ "template id", workoutTemplate.WorkoutTemplateID.ToString () },
{ "is member attached", writeUserMapping.ToString () },
{ "Member name", writeUserMapping ? _selectedUser.FName + " " + _selectedUser.LName : "" },
{ "Profile id", writeUserMapping ? _selectedUser.ProfileID.ToString () : "" },
{ "logged feedback", completedWorkoutsSwitch.IsToggled.ToString () }
});
if (_isFeedbackOnly) {
// int stackCount = Navigation.NavigationStack.Count;
// Navigation.RemovePage (Navigation.NavigationStack [stackCount - 1]);
// Navigation.RemovePage (Navigation.NavigationStack [stackCount - 2]);
// Navigation.RemovePage (Navigation.NavigationStack [stackCount - 3]);
await App.Current.MainPage.Navigation.PopAsync(false);
await App.Current.MainPage.Navigation.PopAsync(false);
await App.Current.MainPage.Navigation.PopAsync(true);
} else {
await Navigation.PopToRootAsync (true);
}
}
UserExerciseGroup CreateUserExerciseGroup (WorkoutTemplate workoutTemplate)
{
UserExerciseGroup userExerciseGroup = new UserExerciseGroup ();
userExerciseGroup.TemplateName = workoutTemplate.TemplateName;
userExerciseGroup.TemplateDescription = workoutTemplate.TemplateDescription;
userExerciseGroup.LastUpdatedTime = DateTime.UtcNow;
userExerciseGroup.ProfileID = _selectedUser.ProfileID;
userExerciseGroup.GymID = workoutTemplate.GymID;
return userExerciseGroup;
}
public MemberTemplateViewModel (WorkoutTemplate workoutTemplate, int gymID, User user)
{
this.WorkoutTemplate = workoutTemplate;
this.GymID = gymID;
this.User = user;
}
public static UserWorkoutTemplateMappingsDTO CreateWorkoutTemplateExercisesDTO(ObservableCollection<ExerciseViewModel> exercises, WorkoutTemplate template, int profileID, bool logFeedback)
{
UserWorkoutTemplateMappingsDTO returnValue = new UserWorkoutTemplateMappingsDTO ();
returnValue.GymID = template.GymID;
returnValue.TemplateName = template.TemplateName;
returnValue.TemplateDescription = template.TemplateDescription;
returnValue.TemplateImageName = "skinandbones.png";
returnValue.LastUpdatedContext = "MobileFit_Coach";
returnValue.AssignToProfileID = profileID;
returnValue.LogFeedback = logFeedback;
returnValue.WorkoutTemplateExercises = new List<UserWorkoutTemplateMapping> ();
int sequence = 1;
foreach (ExerciseViewModel exerciseViewModel in exercises) {
UserWorkoutTemplateMapping workoutTemplate = new UserWorkoutTemplateMapping ();
workoutTemplate.ExerciseID = exerciseViewModel.Exercise.ExerciseID;
workoutTemplate.TargetSets = exerciseViewModel.Sets;
workoutTemplate.TargetReps = exerciseViewModel.Reps;
//workoutTemplate.TargetHRMin = exerciseViewModel.TargetHRMin;
//workoutTemplate.TargetHRMax = exerciseViewModel.TargetHRMax;
workoutTemplate.TargetDurationMin = exerciseViewModel.Duration;
workoutTemplate.TargetWeight = exerciseViewModel.Weight;
workoutTemplate.LastUpdatedContext = "MobileFit_Coach";
workoutTemplate.ExerciseSequence = sequence++;
returnValue.WorkoutTemplateExercises.Add (workoutTemplate);
}
return returnValue;
}
public async static Task DeleteTemplate(WorkoutTemplate workoutTemplate)
{
var db = DependencyService.Get<ISQLite>().GetAsyncConnection();
await db.CreateTableAsync<WorkoutTemplate>();
await db.DeleteAsync(workoutTemplate);
}
public async static Task<WorkoutTemplate> GetWorkoutTemplateByServerTemplateID(int gymID, int serverTemplateID)
{
WorkoutTemplate template = new WorkoutTemplate();
var db = DependencyService.Get<ISQLite>().GetAsyncConnection();
await db.CreateTableAsync<WorkoutTemplate>();
template = await db.Table<WorkoutTemplate>().Where(row => row.WorkoutTemplateID == serverTemplateID && row.GymID == gymID).FirstOrDefaultAsync();
return template;
}
private async static Task<bool> SyncTemplatesWithServer(int gymID, string getServiceType, string dateString)
{
bool returnValue = false;
try
{
var workoutTemplateDTOList = await CoachServices.SyncTemplatesWithServer(gymID, dateString);
if (workoutTemplateDTOList.Count > 0)
{
foreach (WorkoutTemplate workoutTemplateDTO in workoutTemplateDTOList)
{
DateTime lastTimeUpdateDateTime = DateTime.Parse(workoutTemplateDTO.LastUpdatedTime);
WorkoutTemplate workoutTemplate = await WorkoutTemplateDAL.GetWorkoutTemplateByServerTemplateID(gymID, workoutTemplateDTO.WorkoutTemplateID);
if (workoutTemplate == null)
{
workoutTemplate = new WorkoutTemplate();
}
//add workout template property values
workoutTemplate.TemplateName = workoutTemplateDTO.TemplateName;
workoutTemplate.TemplateDescription = workoutTemplateDTO.TemplateDescription;
workoutTemplate.GymID = workoutTemplateDTO.GymID;
workoutTemplate.LastUpdatedTimeDT = lastTimeUpdateDateTime;
workoutTemplate.WorkoutTemplateID = workoutTemplateDTO.WorkoutTemplateID;
//add or modify in the database
await WorkoutTemplateDAL.AddModifyTemplate(workoutTemplate);
//Determine if there are exercises that need to be mapped to the user. If so, map them
var workoutTemplateExercises = workoutTemplateDTO.WorkoutTemplateExercises;
if (workoutTemplateExercises != null)
{
if (workoutTemplateExercises.Count > 0)
{
List<WorkoutTemplateMapping> workoutTemplateMappingList = new List<WorkoutTemplateMapping>();
foreach (var workoutExercise in workoutTemplateExercises)
{
string lastUpdatedTimeString = workoutExercise.LastUpdatedTime;
DateTime lastUpdatedTime = DateTime.Parse(lastUpdatedTimeString);
//Create a workouttemplatemapping model object
WorkoutTemplateMapping workoutTemplateMapping = new WorkoutTemplateMapping();
workoutTemplateMapping.ExerciseID = workoutExercise.ExerciseID;
workoutTemplateMapping.Sets = workoutExercise.TargetSets;
workoutTemplateMapping.Reps = workoutExercise.TargetReps;
workoutTemplateMapping.TargetDurationMin = workoutExercise.TargetDurationMin;
workoutTemplateMapping.TargetHRMin = workoutExercise.TargetHRMin;
workoutTemplateMapping.TargetHRMax = workoutExercise.TargetHRMax;
workoutTemplateMapping.ExerciseSequence = workoutExercise.ExerciseSequence;
workoutTemplateMapping.LastUpdatedTime = lastUpdatedTime;
workoutTemplateMapping.WorkoutTemplateID = workoutTemplate.Id;
workoutTemplateMappingList.Add(workoutTemplateMapping);
}
//Insert created userworkouttemplatemapping model objects into the database
await WorkoutTemplateMappingDAL.CreateWorkoutTemplateMapping(workoutTemplate.Id, workoutTemplateMappingList);
}
}
}
returnValue = true;
}
else {
returnValue = false;
}
}
catch (Exception e)
{
returnValue = false;
Insights.Report(e);
//ErrorLogDAL.AddErrorLogRecord (e, DateTime.UtcNow, gymID, "SyncTemplatesWithServer", "getServiceType : " + getServiceType + ", dateString: " + dateString, e.Message, e.StackTrace);
}
if (returnValue)
{
//Time stame the request by creating a serversynctracking object and writing to the database
APISyncTracking serverSyncTrackingRecord = new APISyncTracking();
serverSyncTrackingRecord.Date = DateTime.UtcNow;
serverSyncTrackingRecord.DebugInfo = "";
serverSyncTrackingRecord.GetServiceType = getServiceType;
ServerSyncTrackingDAL.AddModifyServerSyncTrackingRecord(serverSyncTrackingRecord);
}
return returnValue;
}
