private List <AnalyticsItem> GetExerciseProgress() { List <AnalyticsItem> exerciseProgress = _userExercises.GroupBy(e => e.Definition).Select(g => { ExerciseDefinition def = _userExerciseDefinitions.FirstOrDefault(d => d.Id == g.First().Definition); Exercise firstExercise = _userExercises.FirstOrDefault(ex => ex.Id == def.History?.FirstOrDefault()); var total = g.Sum(t => (double)t.NetValue); var numberOfSessions = g.Count(); double progressPercent = 0.0; if (firstExercise != null) { double initialNetValue = ExerciseUtilities.GetNetExerciseValue(firstExercise); // Progress percent = average net value - initial net value progressPercent = (total / numberOfSessions) - initialNetValue; } return(new AnalyticsItem { Marker = def.Title, Count = progressPercent, }); }).OrderByDescending(a => a.Count).ToList(); return(exerciseProgress); }
public ExercisePage(Guid workoutInstance, ExerciseDefinition def) { _definition = def; _workoutInstance = workoutInstance; var exercisePosition = new Label { Text = def.Hold }; Title = "Exercise Page in C#"; Content = new StackLayout { Children = { new ExerciseTitle(def), new Label { Text = def.Hold }, new PreviousResults(App.TopScores.Load(def.Id)), Clock, ResultsGrid(def) } }; }
private List <AnalyticsItem> GetMuscleGroupFrequency() { // Increment muscle group by occurance Dictionary <string, int> muscleGroupFrequency = new Dictionary <string, int>(); _userExercises.GroupBy(e => e.Definition).ToList().ForEach(g => { ExerciseDefinition exerciseDefiniton = _userExerciseDefinitions.FirstOrDefault(def => def.Id == g.First().Definition); exerciseDefiniton.PrimaryMuscleGroup.ForEach(m => { if (muscleGroupFrequency.ContainsKey(m)) { muscleGroupFrequency[m] += g.Count(); } else { muscleGroupFrequency.Add(m, g.Count()); } }); }); // Convert dictionary to analytics list List <AnalyticsItem> muscleGroupFrequencyList = new List <AnalyticsItem>(); foreach (KeyValuePair <string, int> muscleGroup in muscleGroupFrequency) { muscleGroupFrequencyList.Add(new AnalyticsItem() { Marker = muscleGroup.Key, Count = muscleGroup.Value }); } muscleGroupFrequencyList.Sort((a, b) => a.Count < b.Count ? 1 : -1); return(muscleGroupFrequencyList); }
public async Task <IActionResult> Update(ExerciseDefinition updatedExercise) { var definition = await _mediator.Send(new GetExerciseDefinitionById { DefinitionId = updatedExercise.Id }); if (definition == null) { return(NotFound()); } if (definition.User != User.FindFirst(ClaimTypes.NameIdentifier).Value) { return(Unauthorized()); } var updatedDefinition = await _mediator.Send(new UpdateExerciseDefinition { ExistingDefinition = definition, UpdatedDefinition = updatedExercise }); return(Ok(updatedDefinition)); }
public async Task DeleteExercise(string id, ExerciseDefinition definiton) { await _exerciseContext.DeleteByIdAsync(id); // Remove exercise from definition history definiton.History.Remove(id); await _exerciseDefinitionContext.ReplaceOneAsync(definiton); }
public async Task <ExerciseDefinition> UpdateDefinition(ExerciseDefinition existingDefinition, ExerciseDefinition updatedDefinition) { existingDefinition.Title = updatedDefinition.Title; existingDefinition.Unit = updatedDefinition.Unit; existingDefinition.PrimaryMuscleGroup = updatedDefinition.PrimaryMuscleGroup; await _exerciseDefinitionContext.ReplaceOneAsync(existingDefinition); return(existingDefinition); }
private static async Task <List <ExerciseDefinition> > AddExerciseDefinition(ExerciseDefinition model) { var client = new DocumentClient(new Uri("https://gymnotes.documents.azure.com:443"), "ocCyErceT/NWyuLFwOXTi1KIsT59oC1aiboEgx56R1DoOAmegoeYhIolEZK/ZB8UirfBhn/7ZmfqP5bk/5oNmg=="); var database = await GetDb(client); var collection = await GetCollection("Exercises"); await client.CreateDocumentAsync(collection.SelfLink, model); return(await GetExerciseDefinitions()); }
public async Task <ExerciseDefinition> CreateDefinition(string userId, ExerciseDefinition definition) { await _exerciseDefinitionContext.InsertOneAsync(definition); // Update user's exercises with new exercise User user = await _userContext.FindByIdAsync(userId); user.Exercises.Add(definition.Id); await _userContext.ReplaceOneAsync(user); return(definition); }
public async Task DeleteDefinition(ExerciseDefinition definition) { await _exerciseDefinitionContext.DeleteByIdAsync(definition.Id); // Remove definition from user exercises User user = await _userContext.FindByIdAsync(definition.User); user.Exercises.Remove(definition.Id); await _userContext.ReplaceOneAsync(user); // Remove exercises associated with definition await _exerciseContext.DeleteManyAsync(e => e.Definition == definition.Id); }
public void Display(ExerciseDefinition definition) { var s = new StringBuilder() .Append(definition.Quantity) .Append(' '); if (definition.IsDuration) { s.Append("second "); } s.Append(definition.Exercise.ToLower()); Text = s.ToString(); }
public async Task <IActionResult> CreateDefinition(ExerciseDefinition exerciseToCreate) { string userId = User.FindFirst(ClaimTypes.NameIdentifier).Value; if (exerciseToCreate.User != userId) { return(Unauthorized()); } var definition = await _mediator.Send(new CreateExerciseDefinition { UserId = userId, Definition = exerciseToCreate }); return(CreatedAtRoute("GetExerciseDefinition", new { id = definition.Id }, definition)); }
public async Task <Exercise> CreateExercise(Exercise exercise, ExerciseDefinition definition) { exercise.Date = DateTime.Now; await _exerciseContext.InsertOneAsync(exercise); Exercise latestExercise = await _exerciseContext.FindByIdAsync(definition.History.LastOrDefault()); // Add exercise to definition history definition.History.Add(exercise.Id); // Update definition aggregate fields definition.LastSession = exercise; if (latestExercise != null) { definition.LastImprovement = GetLatestExerciseImprovement(exercise, latestExercise); } await _exerciseDefinitionContext.ReplaceOneAsync(definition); return(exercise); }
private Grid ResultsGrid(ExerciseDefinition exerciseDefinition) { var grid = GridUtility.MakeGrid(1, 5); var currentResult = 1; var currentRow = 0; var currentColumn = 0; for (int i = 0; i < exerciseDefinition.Quantity; i++) { if (currentColumn == 5) //this row is full, create a new row to fill and set the column back to the left side. { grid.RowDefinitions.Add(GridUtility.StandardRow()); currentRow++; currentColumn = 0; } grid.Children.Add(ResultButton(currentResult), currentColumn, currentRow); currentColumn++; currentResult++; } return(grid); }
public ExerciseTitle(ExerciseDefinition definition) { Display(definition); }
public void a_history(ExerciseDefinition definition, string correctlyFormatted) { _sut = new ExerciseTitle(definition); _sut.Text.Should().Be(correctlyFormatted); }