private async Task PostWorkoutToServer(NetworkService ns, Workout cWorkout)
{
var response = await ns.PostWorkout(CurrentUser.Id, cWorkout);
if (response.IsSuccessStatusCode)
{
Workout result = await GetObjectFromResponseAsync <Workout>(response);
cWorkout.ServerId = result.Id;
cWorkout.ExerciseItems = new List <ExerciseItem>();
cWorkout.State = StoreItemState.EqualsWithServer;
foreach (var item in result.ExerciseItems)
{
var newExerciseItem = new ExerciseItem
{
Exercise = _context.Exercises.SingleOrDefault(e => e.Name.Equals(item.Exercise.Name)),
Reps = item.Reps,
State = StoreItemState.EqualsWithServer,
ServerId = item.Id,
Serial = item.Serial
};
cWorkout.ExerciseItems.Add(newExerciseItem);
}
}
}
private void OnItemSelect(object sender, SelectedItemChangedEventArgs e)
{
_selectedExercise = (ExerciseItem)exerciseListView.SelectedItem;
var detailPage = new ExerciseDetailPage(_selectedExercise);
Navigation.PushAsync(detailPage);
}
/// <summary>
/// Toggle adding or removing exercises to the new workout
/// </summary>
/// <param name="item"></param>
private void onClickExerciseItem(ListViewItem item)
{
Image buttonImage = item.button.GetComponent <Image>();
if (!originalButtonColorSet)
{
originalButtonColor = buttonImage.color;
pressedButtonColor = new Color(
originalButtonColor.r / 2,
originalButtonColor.g / 2,
originalButtonColor.b / 2,
originalButtonColor.a);
originalButtonColorSet = true;
}
ExerciseItem exerciseItem = (ExerciseItem)item;
bool itemRemoved = newWorkout.exercises.ContainsKey(exerciseItem.data.name);
if (itemRemoved)
{
newWorkout.exercises.Remove(exerciseItem.data.name);
buttonImage.color = originalButtonColor;
}
else
{
newWorkout.exercises[exerciseItem.data.name] = exerciseItem.data;
buttonImage.color = pressedButtonColor;
}
totalTimeText.setTimeText(newWorkout.getTotalWorkoutTimeInSeconds());
doValueAnimation(totalTimeText.transform);
//MobilePopup.Instance.toast.show(message);
}
private void ShowEditRosterDialog()
{
var dialogViewModel = new EditRosterViewModel(AllExerciseItems);
List <ExerciseItem> temp = AllExerciseItems.ToList();
bool?success = dialogService.ShowDialog <EditRosterView>(this, dialogViewModel);
if (success == true)
{
ExerciseItemsToDo.Clear();
foreach (var rosterItem in dialogViewModel.RosterItems)
{
ExerciseItem exerciseItem = temp.FirstOrDefault(x => x.GUIDID == rosterItem.GUIDID);
exerciseItem.IsUsedInRoster = rosterItem.IsUsedInRoster;
dataStore.UpdateIsUsedInRoster(exerciseItem);
RaisePropertyChangedEvent("IsUsedInRoster");
if (!temp.Contains(exerciseItem))
{
exerciseItem.DueTime = DateTime.Now;
}
if (exerciseItem.IsUsedInRoster)
{
ExerciseItemsToDo.Add(exerciseItem);
}
}
RebuildList();
}
else //revert it to the way it was
{
}
}
private async Task PutWorkoutToServer(NetworkService ns, Workout cWorkout)
{
foreach (var item in cWorkout.ExerciseItems)
{
if (item.State != StoreItemState.DeletedFromClientSide)
{
item.State = StoreItemState.UpdatedFromClientSide;
}
}
var response = await ns.PutWorkout(CurrentUser.Id, cWorkout);
if (response.IsSuccessStatusCode)
{
Workout result = await GetObjectFromResponseAsync <Workout>(response);
cWorkout.ExerciseItems.RemoveAll(e => true);
foreach (var item in result.ExerciseItems)
{
var newExerciseItem = new ExerciseItem
{
Exercise = _context.Exercises.SingleOrDefault(e => e.Name.Equals(item.Exercise.Name)),
Reps = item.Reps,
State = StoreItemState.EqualsWithServer,
ServerId = item.Id,
Serial = item.Serial
};
cWorkout.ExerciseItems.Add(newExerciseItem);
}
cWorkout.State = StoreItemState.EqualsWithServer;
}
}
private void OnMarkExerciseCompletedChanged(object sender, EventArgs e)
{
ExerciseItem ex = sender as ExerciseItem;
dataStore.UpdateDueTime(ex);
dataStore.AddHistoryItem(new ExerciseHistoryItem(ex.GUIDID, ex.IsRepetitions, DateTime.Now, ex.RequiredReps, ex.RequiredTime, (int)ex.ExerciseTimeUnits));
RebuildList();
}
public CreateExerciseViewModel()
{
Guid newGUIDID = Guid.NewGuid();
itemToAdd = new ExerciseItem(newGUIDID.ToString());
IsUsedInRoster = true;
Weight = 10;
}
public void TestCase_ExerciseItem_Equals2()
{
var ei = new ExerciseItem();
ei.ExerciseType = ExerciseItemType.Question;
ei.Content = "Test1";
Assert.Throws <InvalidOperationException>(() => ei.Equals(null));
}
private void OnDeleteExercise(object sender, EventArgs e)
{
ExerciseItem itemToDelete = sender as ExerciseItem;
ExerciseItemsToDo.Remove(itemToDelete);
AllExerciseItems.Remove(itemToDelete);
dataStore.DeleteExercise(itemToDelete);
RebuildList();
}
public ExerciseSerialRepsPopup(ExerciseItem currentItem)
{
InitializeComponent();
Content.BackgroundColor = Color.Transparent;
RepsLabel.Text = currentItem.Reps.ToString();
SerialLabel.Text = currentItem.Serial.ToString();
RepsStepper.Value = currentItem.Reps;
SerialStepper.Value = currentItem.Serial;
_currentItem = currentItem;
}
public void CanDeleteExercise()
{
string ExerciseName = "Test";
ExerciseItem theOne = showAndCreateExercise(ExerciseName);
DeleteExercise(theOne);
dialogService.VerifyAll();
Assert.IsFalse(mainWindowViewModel.ExerciseItemsToDo.Any(x => x.ExerciseName == ExerciseName));
}
public void CanCompleteExercises()
{
string exerciseName = "Test";
showAndCreateExercise(exerciseName, dueTime: DateTime.Now);
ExerciseItem theOne = showAndCreateExercise(exerciseName, dueTime: DateTime.Now);
CompleteExercise(theOne);
Assert.AreEqual(theOne.DueTime.Day, (DateTime.Now + new TimeSpan(1, 0, 0, 0)).Day);
}
public void UpdateDueTime(ExerciseItem exercise)
{
List <object> objectsToWrite = new List <object>()
{
exercise.GUIDID,
exercise.DueTime.ToUniversalTime().ToString("O"),
};
string DueTimeData = nameof(exercise.GUIDID) + ", " + nameof(exercise.DueTime);
DatabaseHelper.UpdateItem(connection, allExercisesTableName, DueTimeData, objectsToWrite);
}
public void UpdateIsUsedInRoster(ExerciseItem exercise)
{
List <object> objectsToWrite = new List <object>()
{
exercise.GUIDID,
exercise.IsUsedInRoster,
};
string IsUsedInRosterData = nameof(exercise.GUIDID) + ", " + nameof(exercise.IsUsedInRoster);
DatabaseHelper.UpdateItem(connection, allExercisesTableName, IsUsedInRosterData, objectsToWrite);
}
public ExerciseItem ToEntity(ExerciseItem e)
{
if (e == null)
{
e = new ExerciseItem();
}
e.Id = Id ?? Guid.NewGuid().ToString();
e.Exercise = Exercise;
e.Reps = Reps;
e.Serial = Serial;
return(e);
}
private async Task <SyncMessage> DownloadUserWorkoutsAsync(NetworkService nS)
{
try
{
List <Workout> sWorkouts = await nS.GetWorkouts(_userId);
List <Workout> cWorkouts = _context.Workouts.ToList();
foreach (var sWorkout in sWorkouts)
{
var cWorkout = cWorkouts.SingleOrDefault(w => w.ServerId.Equals(sWorkout.Id));
if (cWorkout == null)
{
cWorkout = new Workout
{
Difficulty = sWorkout.Difficulty,
State = StoreItemState.EqualsWithServer,
Name = sWorkout.Name,
UserId = _userId,
ServerId = sWorkout.Id,
ExerciseItems = new List <ExerciseItem>()
};
foreach (var item in sWorkout.ExerciseItems)
{
var newExerciseItem = new ExerciseItem
{
Exercise = _context.Exercises.SingleOrDefault(e => e.Name.Equals(item.Exercise.Name)),
Reps = item.Reps,
State = StoreItemState.EqualsWithServer,
ServerId = item.Id,
Serial = item.Serial
};
cWorkout.ExerciseItems.Add(newExerciseItem);
}
_context.Workouts.Add(cWorkout);
}
}
await _context.SaveChangesAsync();
return(new SyncMessage {
Result = SyncronizationMessages.DownloadInstancesFromServerSucess, IsSucessfull = true
});
}
catch
{
return(new SyncMessage {
Result = SyncronizationMessages.DownloadInstancesFromServerFail
});
}
}
// POST: /ExerciseItems
/// <summary>
/// Support for creating exercise item
/// </summary>
public async Task <IActionResult> Post([FromBody] ExerciseItem execitem)
{
if (!ModelState.IsValid)
{
foreach (var value in ModelState.Values)
{
foreach (var err in value.Errors)
{
System.Diagnostics.Debug.WriteLine(err.Exception?.Message);
}
}
return(BadRequest());
}
// Admin. fields
execitem.CreatedAt = DateTime.Now;
execitem.ModifiedAt = null;
//if (execitem.Answer != null)
//{
// execitem.Answer.ExerciseItem = execitem;
//}
//ExerciseItemAnswer execawr = null;
//if (execitem.Answer != null)
//{
// execawr = new ExerciseItemAnswer();
// execawr.Content = execitem.Answer.Content;
// execitem.Answer = null;
//}
if (execitem.Tags.Count > 0)
{
foreach (var tag in execitem.Tags)
{
tag.CurrentExerciseItem = execitem;
}
}
// Update db
_context.ExerciseItems.Add(execitem);
await _context.SaveChangesAsync();
// Answer
//if (execawr != null)
//{
// execawr.ItemID = execitem.ID;
// _context.ExerciseItemAnswers.Add(execawr);
// await _context.SaveChangesAsync();
//}
return(Created(execitem));
}
private void DeleteExercise(ExerciseItem exerciseItem)
{
dialogService.Setup(mock => //must 100% match the one used in code. Should make these a single item so that it can be called easier
mock.ShowMessageBox(
exerciseItem,
It.IsAny <string>(),
It.IsAny <string>(),
MessageBoxButton.YesNo,
MessageBoxImage.None,
MessageBoxResult.None))
.Returns(MessageBoxResult.Yes);
exerciseItem.DeleteThisExerciseCommand.Execute(null);
}
public void TestCase_ExerciseItem_Equals()
{
var ei = new ExerciseItem();
ei.ExerciseType = ExerciseItemType.Question;
ei.Content = "Test1";
var ei2 = new ExerciseItem();;
ei2.ExerciseType = ExerciseItemType.EssayQuestions;
ei2.Content = "Test2";
var rst = ei.Equals(ei2);
Assert.False(rst);
}
//Jig/HelperFunctions----------------------------------------------------------------------------------------------
//If this gets to big and messy, could probably move it to its own helper class provided that doesnt make more problems
private ExerciseItem showAndCreateExercise(string exerciseName, bool isUsedInRoster = true, DateTime dueTime = new DateTime())
{
ExerciseItem addedExercise = new ExerciseItem();
dialogService
.Setup(mock => mock.ShowDialog <CreateExerciseView>(mainWindowViewModel, It.IsAny <CreateExerciseViewModel>()))
.Returns(true)
.Callback((INotifyPropertyChanged ownerViewModel, CreateExerciseViewModel createExerciseViewModel) =>
{
createExerciseViewModel.ExerciseNameToAdd = exerciseName;
createExerciseViewModel.IsUsedInRoster = isUsedInRoster;
createExerciseViewModel.ItemToAdd.DueTime = dueTime;
addedExercise = createExerciseViewModel.ItemToAdd;
});
mainWindowViewModel.ShowCreateExerciseCommand.Execute(null);
return(addedExercise);
}
private async Task <ObservableCollection <ExerciseItem> > GetExercises()
{
var collection = new ObservableCollection <ExerciseItem>();
var list = await _exercisesRepository.AllAsync();
foreach (var item in list)
{
var vm = new ExerciseItem
{
Exercise = item,
TrainingDays = await _exercisesRepository.GetTrainingDays(item)
};
collection.Add(vm);
}
return(collection);
}
public async Task <IActionResult> PostWorkout([FromRoute] string userId,
[FromBody] Workout workout)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
List <ExerciseItem> newExerciseItems = new List <ExerciseItem>();
foreach (var exerciseItem in workout.ExerciseItems)
{
ExerciseItem newExerciseItem = new ExerciseItem()
{
Exercise = _context.Exercises
.SingleOrDefault(e => exerciseItem.Exercise.Name.Equals(e.Name)),
Reps = exerciseItem.Reps,
Serial = exerciseItem.Serial,
};
newExerciseItems.Add(newExerciseItem);
}
Workout newItem = new Workout()
{
Difficulty = workout.Difficulty,
ExerciseItems = newExerciseItems,
Name = workout.Name,
};
var user = _context.Users.SingleOrDefault(u => u.Id.Equals(userId));
if (user == null)
{
return(BadRequest());
}
user.Workouts.Add(newItem);
_context.Workouts.Add(newItem);
newItem.ServerId = newItem.Id;
foreach (var item in newItem.ExerciseItems)
{
item.ServerId = item.Id;
}
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorkout", new { id = newItem.Id }, newItem));
}
//Each type of show graph function will have to set up the graph on its own
private void ShowExerciseHistory(ExerciseItem exercise)
{
//for this mode, we need to setup the graph so that it will display a fixed set of days on the graph(scatter plot)
XAxisTitle = exercise.ExerciseName;
YAxisTitle = "Day of the Year completed (This needs to change)";
GraphData = new SeriesCollection();
GraphData.Add(new ScatterSeries()
{
Values = new ChartValues <int>()
});
XLabels = new List <string>();
XSeperatorEnabled = true;
List <ExerciseHistoryItem> allHistory = datastore.LoadExerciseHistory(exercise);
allHistory = allHistory.OrderBy(x => x.TimeCompleted).ToList();
//DateTime dateStart = allHistory.FirstOrDefault().TimeCompleted;
//DateTime dateEnd = allHistory.LastOrDefault().TimeCompleted;
//while (dateStart.DayOfYear != dateEnd.DayOfYear) //this will obviously not work when the year changes
//{
// XLabels.Add(dateStart.ToShortDateString());
// dateStart += new TimeSpan(1,0,0,0);
//}
foreach (var his in allHistory)
{
XLabels.Add(his.TimeCompleted.ToShortDateString());
if (his.RepsDone != 0)
{
GraphData[0].Values.Add(his.RepsDone);
}
else
{
GraphData[0].Values.Add(his.TimeDone);
}
}
VisualUpdateGraph();
}
public void UpdateExercise(ExerciseItem exercise)
{
List <object> objectsToWrite = new List <object>
{
exercise.GUIDID,
exercise.ExerciseName,
exercise.ExerciseTypeId,
exercise.RequiredReps,
exercise.RequiredTime,
exercise.RequiredSets,
exercise.RequiredSetsCount,
exercise.DueTime.ToUniversalTime().ToString("O"),
exercise.IsUsedInRoster,
exercise.MuscleGroupId,
exercise.Weight,
};
DatabaseHelper.UpdateItem(connection, allExercisesTableName, allExercisesTableData, objectsToWrite);
}
public ExerciseListViewModel(IMasterDetailNavigation navigationService, IMessagingService messagingService, IExercisesRepository exercisesRepository)
{
_navigationService = navigationService;
_messagingService = messagingService;
_exercisesRepository = exercisesRepository;
Title = AppResources.ExercisesTitle;
SelectItemCommand = new Command(async(item) => { await OnItemSelected(item); });
AddExerciseCommand = new Command(async() =>
{
await _navigationService.NavigateToHierarchical <ExerciseDetailsViewModel>();
});
_messagingService.Subscribe <ExerciseDetailsViewModel, Exercise>(this, Messages.ItemAdded, async(sender, e) =>
{
var item = new ExerciseItem
{
Exercise = e,
TrainingDays = await _exercisesRepository.GetTrainingDays(e)
};
Exercises.Add(item);
UpdateVisible();
});
_messagingService.Subscribe <ExerciseDetailsViewModel, Exercise>(this, Messages.ItemChanged, async(sender, e) =>
{
var item = Exercises.FirstOrDefault(x => x.Exercise.ExerciseId == e.ExerciseId);
if (item == null)
{
return;
}
item.Exercise = null;
item.Exercise = e;
item.TrainingDays = await _exercisesRepository.GetTrainingDays(e);
});
_messagingService.Subscribe <ExerciseDetailsViewModel>(this, Messages.ItemDeleted, sender =>
{
var item = Exercises.FirstOrDefault(x => x.Exercise.ExerciseId == sender.ExerciseId);
Exercises.Remove(item);
UpdateVisible();
});
}
private void OnEditExercise(object sender, EventArgs e)
{
ExerciseItem itemToEdit = sender as ExerciseItem;
//This is a somewhat custom version of the create exercise window
var dialogViewModel = new CreateExerciseViewModel();
dialogViewModel.ItemToAdd = itemToEdit;
bool?success = dialogService.ShowDialog <CreateExerciseView>(this, dialogViewModel);
if (success == true)
{
dataStore.UpdateExercise(dialogViewModel.ItemToAdd);
if (dialogViewModel.ItemToAdd.IsUsedInRoster)
{
//OnUpdateTimerTick(null, null);
RebuildList(); //have to rebuild list so that it updates the views
}
}
}
// POST: /ExerciseItems
/// <summary>
/// Support for creating exercise item
/// </summary>
public async Task <IActionResult> Post([FromBody] ExerciseItem execitem)
{
if (!ModelState.IsValid)
{
foreach (var value in ModelState.Values)
{
foreach (var err in value.Errors)
{
System.Diagnostics.Debug.WriteLine(err.Exception?.Message);
}
}
return(BadRequest(ModelState));
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
return(new UnauthorizedResult());
}
// Admin. fields
execitem.CreatedAt = DateTime.Now;
execitem.ModifiedAt = null;
if (execitem.Tags.Count > 0)
{
foreach (var tag in execitem.Tags)
{
tag.CurrentExerciseItem = execitem;
}
}
// Update db
_context.ExerciseItems.Add(execitem);
await _context.SaveChangesAsync();
return(Created(execitem));
}
public DailyWorkout InsertDailyWorkout(DailyWorkout newDailyWorkout, ApplicationUser user)
{
if (!IsValidDailyWorkout(newDailyWorkout))
{
throw new NotValidStateException();
}
List <ExerciseItem> exercises = new List <ExerciseItem>();
foreach (var exercise in newDailyWorkout.Exercises)
{
var exerciseToSave = new ExerciseItem()
{
Name = exercise.Name,
Reps = exercise.Reps,
SerialNumber = exercise.SerialNumber,
Description = exercise.Description,
MuscleGroup = exercise.MuscleGroup
};
_exerciseContext.ExerciseItems.Add(exerciseToSave);
exercises.Add(exerciseToSave);
}
_exerciseContext.SaveChanges();
var savedInstance = new DailyWorkout()
{
Name = newDailyWorkout.Name,
WorkoutType = newDailyWorkout.WorkoutType,
Exercises = exercises
};
savedInstance.UserID = user.Id;
user.DailyWorkouts.Add(savedInstance);
_context.DailyWorkouts.Add(savedInstance);
_context.SaveChanges();
return(savedInstance);
}
public void UpdateDailyWorkout(int id, DailyWorkout updatedDailyWorkout)
{
var current = _context.DailyWorkouts
.Include(dw => dw.Exercises)
.SingleOrDefault(m => m.Id == updatedDailyWorkout.Id);
foreach (var exercise in updatedDailyWorkout.Exercises.ToList())
{
var newexercise = _exerciseContext.ExerciseItems.SingleOrDefault(m => m.Id == exercise.Id);
if (newexercise == null)
{
var newElem = new ExerciseItem()
{
Description = exercise.Description,
Name = exercise.Name,
Reps = exercise.Reps,
SerialNumber = exercise.SerialNumber,
MuscleGroup = exercise.MuscleGroup
};
_exerciseContext.ExerciseItems.Add(newElem);
current.Exercises.Add(newElem);
}
}
current.Name = updatedDailyWorkout.Name;
try
{
_exerciseContext.SaveChanges();
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException e)
{
// Létezett-e egyáltalán
var _ = _context.DailyWorkouts.AsNoTracking().SingleOrDefault(p => p.Id == id)
?? throw new EntityNotFoundException("Nem található az edzés");
throw;
}
}
public List <ExerciseHistoryItem> LoadExerciseHistory(ExerciseItem exercise)
{
string guidname = nameof(nameHistoryItem.ExerciseGUIDID);
DataTable dt = DatabaseHelper.LoadItems(connection, exerciseHistoryTableName, exerciseHistoryTableData, new List <string>()
{
guidname
}, new List <object>()
{
exercise.GUIDID
});
List <ExerciseHistoryItem> history = (from rw in dt.AsEnumerable()
select new ExerciseHistoryItem(
Convert.ToString(rw[nameof(nameHistoryItem.ExerciseGUIDID)]),
Convert.ToBoolean(rw[nameof(nameHistoryItem.IsRep)]),
Convert.ToDateTime(rw[nameof(nameHistoryItem.TimeCompleted)]),
Convert.ToInt32(rw[nameof(nameHistoryItem.RepsDone)]),
Convert.ToInt32(rw[nameof(nameHistoryItem.TimeDone)]),
Convert.ToInt32(rw[nameof(nameHistoryItem.ExerciseTimeUnitsId)]))
).ToList();
return(history);
}
