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