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); }