public async Task <ResponseModel> Create(ExerciseModel model)
{
var response = new ResponseModel();
if (model == null)
{
throw new NullParameterException();
}
await _context.ExerciseRepository.AddAsync(new Exercise()
{
Id = Guid.NewGuid(),
MainMuscleId = new Guid(model.MainMuscleId),
SecondaryMuscleIds = model.SecondaryMuscleIds,
Name = model.Name,
Description = model.Description,
Notes = model.Notes,
HardLevel = model.HardLevel,
Precedence = model.Precedence,
IsActive = model.IsActive,
CreatedBy = model.CreatedBy,
CreatedDate = DateTime.Now
});
await _context.SaveChangesAsync().ConfigureAwait(false);
return(response);
}
public ActionResult <AllExercises> GetExercises(long id)
{
var userName = User.Claims.Single(a => a.Type == ClaimTypes.NameIdentifier).Value;
var exercise = _context.Exercises
.Where(i => i.Creator == userName && i.Id == id).Include(i => i.Sets)
.First();
if (exercise == null)
{
return(NotFound("Exercise was not found"));
}
var exerciseResponse = new ExerciseModel()
{
ExerciseName = exercise.Name,
Id = exercise.Id,
Type = exercise.ExerciseType,
Sets = exercise.Sets.Select(i => new SetModel
{
Id = i.Id,
RepCount = i.RepCount,
Weights = i.Weight
}).ToList()
};
return(Ok(exerciseResponse));
}
public TestScore(ExerciseModel e)
{
Type = TestType.Exercise;
Date = e.exerciseDate;
Score = e.exerciseScore;
SubjectId = e.SubjectId;
}
public async Task <ResponseModel> Delete(ExerciseModel model)
{
var response = new ResponseModel();
if (model == null)
{
throw new NullParameterException();
}
var item = await _context.ExerciseRepository.FirstOrDefaultAsync(m => m.Id == new Guid(model.Id)).ConfigureAwait(true);
if (item == null)
{
throw new ItemNotFoundException();
}
item.Deleted = true;
item.DeletedBy = model.UpdatedBy;
item.DeletedDate = DateTime.Now;
_context.ExerciseRepository.Update(item);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(response);
}
public List <ExerciseModel> GetAllExercises(int workoutId)
{
List <ExerciseModel> tempExercises = new List <ExerciseModel>();
using (SqlConnection connection = new SqlConnection(AppSettingsJson.GetConnectionstring()))
{
connection.Open();
SqlCommand dataCommand = new SqlCommand()
{
CommandText = "Select* FROM [Exercises] Inner join [Exercise_Workout] on [Exercises].ExerciseId = [Exercise_Workout].ExerciseId where [Exercise_Workout].WorkoutId = '" + workoutId + "'",
Connection = connection
};
using (SqlDataReader exerciseReader = dataCommand.ExecuteReader())
{
while (exerciseReader.Read())
{
ExerciseModel tempExercise = new ExerciseModel(exerciseReader["Name"].ToString(), Convert.ToInt32(exerciseReader["Repetitions"]), exerciseReader["Skillevel"].ToString());;
tempExercises.Add(tempExercise);
}
exerciseReader.Close();
return(tempExercises);
}
}
}
public async Task <IHttpActionResult> UpdateExercise([FromUri] int id, [FromBody] ExerciseModel exercise)
{
if (id != exercise.Id)
{
ModelState.AddModelError("id", "The given id have to be the same as in the model");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var exists = await this.AppRepository.Exercise.ExistsAsync(id);
try
{
var orig = await this.AppRepository.Exercise.FindAsync(id);
orig = this.TheModelFactory.CreateModel(exercise, orig);
await this.AppRepository.Exercise.UpdateAsync(orig);
}
catch (DbUpdateConcurrencyException)
{
if (!exists)
{
return(NotFound());
}
throw;
}
return(StatusCode(HttpStatusCode.NoContent));
}
public bool createExercise(ExerciseModel exercise)
{
string query = "INSERT INTO exercises (name) VALUES (@name)";
object paramObj = new { name = exercise.name };
return(this.Execute(query, paramObj));
}
/*int SortByDate(LogModel a, LogModel b)
* {
* DateTime a1 = DateTime.ParseExact(a.Date, "dd/MM/yy", CultureInfo.InvariantCulture);
* DateTime b1 = DateTime.ParseExact(b.Date, "dd/MM/yy", CultureInfo.InvariantCulture);
* return a1.CompareTo(b1) * -1;
* }*/
int SortByName(ExerciseModel a, ExerciseModel b)
{
string a1 = a.Name;
string b1 = b.Name;
return(a1.CompareTo(b1));
}
public Boolean CheckAnswer(int QuestionId, string Query, int UserId, out List <AnswerDifferenceModel> Differences)
{
SqlConnection dataSourcesConnection = new SqlConnection(Properties.Settings.Default.DatabaseDataSourcesConnectionString);
dataSourcesConnection.Open();
QuestionModel question = GetQuestion(UserId, QuestionId);
ExerciseModel exercise = GetExercise(UserId, question.ExerciseId);
SqlCommand command = QueryBuilder.BuildDifferenceQuery(
QueryBuilder.BuildCommand(Query, exercise, question, dataSourcesConnection),
QueryBuilder.BuildCommand(question.AnswerTemplate, exercise, question, dataSourcesConnection),
dataSourcesConnection
);
DataTable diffDataTable = new DataTable();
SqlDataReader reader = command.ExecuteReader();
diffDataTable.Load(reader);
Differences = Converters.DataTableToAnswerDifferences(diffDataTable);
dataSourcesConnection.Close();
// The answer is correct if there were no differences
return(diffDataTable.Rows.Count == 0);
}
public List <ExerciseModel> ListExercises(int UserId)
{
List <ExerciseModel> exercises = new List <ExerciseModel>();
List <int> exerciseIds = new List <int>();
using (SqlConnection conn = new SqlConnection(Properties.Settings.Default.DatabaseConnectionString))
{
conn.Open();
using (SqlCommand command = new SqlCommand("select ex_id from exercises where ex_deleted = 0 and ex_published = 1", conn))
{
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
exerciseIds.Add((int)reader["EX_ID"]);
}
reader.Close();
}
}
foreach (int id in exerciseIds)
{
ExerciseModel exercise = GetExercise(UserId, id);
exercises.Add(exercise);
}
return(exercises);
}
public List <ExerciseModel> ListExercises(int UserId)
{
List <ExerciseModel> exercises = new List <ExerciseModel>();
if (_conn.State != ConnectionState.Open)
{
_conn.Open();
}
SqlCommand command = new SqlCommand("select * from exercises order by ex_name asc", _conn);
SqlDataReader reader = command.ExecuteReader();
List <int> exerciseIds = new List <int>();
while (reader.Read())
{
exerciseIds.Add((int)reader["EX_ID"]);
}
reader.Close();
foreach (int id in exerciseIds)
{
ExerciseModel exercise = GetExercise(UserId, id);
exercises.Add(exercise);
}
exercises = exercises.OrderBy(x => x.Name).ToList();
_conn.Close();
return(exercises);
}
public static void RemoveExercise(string type, ExerciseModel exercise)
{
if (type == "Chest")
{
ChestList.Remove(exercise);
}
else if (type == "Back")
{
BackList.Remove(exercise);
}
else if (type == "Legs")
{
LegsList.Remove(exercise);
}
else if (type == "Shoulders")
{
ShouldersList.Remove(exercise);
}
else if (type == "Arms")
{
ArmsList.Remove(exercise);
}
else if (type == "Abs")
{
AbsList.Remove(exercise);
}
App.Current.MainPage.Navigation.PopToRootAsync();
Application.Current.MainPage.Navigation.PushAsync(new WorkoutLogger.Views.ExerciseListPage(type));
DataService.UserDataService.SaveData();
}
public List <ExerciseModel> GetAll(string sortField, int userId)
{
List <ExerciseModel> tempExercises = new List <ExerciseModel>();
using (SqlConnection connection = new SqlConnection(AppSettingsJson.GetConnectionstring()))
{
connection.Open();
SqlCommand dataCommand = new SqlCommand()
{
CommandText = "SELECT * FROM Exercises Inner join User_Exercise on [Exercises].ExerciseId = [User_Exercise].ExerciseId where UserId = '" + userId + "' AND InWorkout = 0 ORDER BY CASE WHEN @sortField = 'Name' Then Name WHEN @sortField = 'Weight' Then Weight WHEN @sortField = 'Repetitions' Then Repetitions WHEN @sortField = 'Date' Then Date END DESC",
Connection = connection
};
SqlParameter sqlParameter = new SqlParameter();
sqlParameter.ParameterName = "@sortfield";
sqlParameter.Value = sortField;
dataCommand.Parameters.Add(sqlParameter);
using (SqlDataReader exerciseReader = dataCommand.ExecuteReader())
{
while (exerciseReader.Read())
{
ExerciseModel tempExercise = new ExerciseModel(Convert.ToInt32(exerciseReader["ExerciseId"]), exerciseReader["Name"].ToString(), Convert.ToInt32(exerciseReader["Weight"]), Convert.ToInt32(exerciseReader["Repetitions"]), ((DateTime)exerciseReader["Date"]).ToString("d/M/yyyy HH:mm:ss"), exerciseReader["Skillevel"].ToString(), (bool)exerciseReader["InWorkout"]);
tempExercises.Add(tempExercise);
}
exerciseReader.Close();
return(tempExercises);
}
}
}
private void CreateExerciseButton_Click(object sender, EventArgs e)
{
if (ValidateForm())
{
ExerciseModel model = new ExerciseModel(exerciseNameValue.Text, numberOfRepetitionsValue.Text, exerciseTimeValue.Text, numberOfSeriesValue.Text, breakBetweenSeriesValue.Text);
if (isCreateExercise)
{
GlobalConfig.Connection.CreateExercise(model);
callingForm.ExerciseComplete(model);
}
if (isUpdateExercise)
{
model.Id = modelToUpdate.Id;
GlobalConfig.Connection.UpdateExercise(modelToUpdate, model);
callingForm.ExerciseUpdateComplete(model);
}
Close();
}
else
{
MessageBox.Show("This form has invalid information. Please check it and try again.", "Invalid information", MessageBoxButtons.OK);
}
}
void SubButton_Clicked(object sender, EventArgs e)
{
ExerciseModel exercise = new ExerciseModel();
if (exerciseName.Text != "" && timeIndex != -1 && setIndex != -1 && repIndex != -1)
{
exercise.name = exerciseName.Text;
exercise.reps = Convert.ToInt32(repPicker.Items[repIndex]); //could be 0
exercise.time = timeIndex * 15; //the time in seconds (could be 0)
exercise.sets = Convert.ToInt32(setPicker.Items[setIndex]); //could be 0
if (Application.Current.Properties.ContainsKey("tempExercises"))
{
var exers = Application.Current.Properties["tempExercises"] as List <ExerciseModel>;
Application.Current.Properties.Remove("tempExercises");
exers.Add(exercise);
Application.Current.Properties["tempExercises"] = exers;
}
else
{
var exers = new List <ExerciseModel>();
exers.Add(exercise);
Application.Current.Properties["tempExercises"] = exers;
}
Navigation.PopModalAsync();
}
else
{
DisplayAlert("Error", "Please add all information about this exercise.", "OK");
}
}
/*
* Generates the user's exercises page
* @return Exercises page view and model
*/
public async Task <IActionResult> Exercises()
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login"));
}
else
{
// Get all of the user's exercises from the database
string userEmail = User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress").Value;
HttpResponseMessage res = await httpClient.GetAsync("http://localhost:8080/exercises/" + userEmail);
// Add all of the user's exercises to the data model
ICollection <ExerciseModel> exercisesModel = new List <ExerciseModel>();
string exercisesStr = await res.Content.ReadAsStringAsync();
dynamic exercisesJson = JsonConvert.DeserializeObject(exercisesStr);
for (int i = 0; i < exercisesJson.Count; i++)
{
ExerciseModel exerciseModel = new ExerciseModel();
exerciseModel.name = exercisesJson[i]["name"];
exerciseModel.set_count = Convert.ToInt32(exercisesJson[i]["set_count"]);
exerciseModel.rep_count = Convert.ToInt32(exercisesJson[i]["rep_count"]);
exerciseModel.weight = Convert.ToInt32(exercisesJson[i]["weight"]);
exerciseModel.muscle_group = exercisesJson[i]["muscle_group"];
exercisesModel.Add(exerciseModel);
}
return(View("Exercises", exercisesModel));
}
}
public async Task <ResponseModel> Edit(ExerciseModel model)
{
var response = new ResponseModel();
if (model == null)
{
throw new NullParameterException();
}
var item = await _context.ExerciseRepository.FirstOrDefaultAsync(m => m.Id == new Guid(model.Id)).ConfigureAwait(true);
if (item == null)
{
throw new ItemNotFoundException();
}
item.Name = model.Name;
item.MainMuscleId = new Guid(model.MainMuscleId);
item.SecondaryMuscleIds = model.SecondaryMuscleIds;
item.Description = model.Description;
item.Notes = model.Notes;
item.HardLevel = model.HardLevel;
item.Precedence = model.Precedence;
item.IsActive = model.IsActive;
item.UpdatedBy = model.UpdatedBy;
item.UpdatedDate = DateTime.Now;
_context.ExerciseRepository.Update(item);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(response);
}
public CircuitPage(CircuitModel circuit)
{
var stack = new StackLayout()
{
HorizontalOptions = LayoutOptions.Center,
VerticalOptions = LayoutOptions.StartAndExpand,
Padding = 50
};
label.Text = circuit.name;
label.TextColor = Color.Black;
List <string> names = new List <string>();
foreach (var circ in circuit.circuit)
{
names.Add(circ.name);
}
list.ItemsSource = names;
list.ItemSelected += async(sender, e) =>
{
if (e.SelectedItem != null)
{
ExerciseModel exerc = null;
foreach (var exercise in circuit.circuit)
{
if (exercise.name.Equals(e.SelectedItem))
{
exerc = exercise;
break;
}
}
var exercisePage = new ExercisePage(exerc);
await Navigation.PushModalAsync(exercisePage);
}
};
Button backButton = new Button()
{
Text = "Back",
TextColor = Color.Black,
BackgroundColor = Color.SkyBlue,
WidthRequest = 40,
VerticalOptions = LayoutOptions.End,
HorizontalOptions = LayoutOptions.Start
};
backButton.Clicked += async(sender, e) =>
{
await Navigation.PopModalAsync(); //go back to viewpage
};
stack.Children.Add(label);
stack.Children.Add(backButton);
this.BackgroundColor = Color.LightGray;
Content = stack;
}
public ActionResult Add(int id)
{
ExerciseModel exercise = _exerciseRepository.Get(id);
exercise.Add = true;
_exerciseRepository.Update(id, exercise);
return(RedirectToAction(nameof(Index)));
}
public void ChangeSelectedExercise(ExerciseModel exercise, string folderPath, string clientName)
{
exerciseLookupViewModel.SelectedExercise = exercise;
var allTrainingsList = TrainingDataMapper.GetAllTrainings(folderPath, clientName);
exerciseLookupViewModel.TrainingList = allTrainingsList;
exerciseLookupViewModel.ExerciseList = new ObservableCollection <ExerciseModel>();
}
public ActionResult Remove(int id)
{
ExerciseModel exercise = _exerciseRepository.Get(id);
exercise.Add = false;
_exerciseRepository.Update(id, exercise);
return(RedirectToAction(nameof(IndexTraining)));
}
public ExerciseController(string activityId, string username, DateTime date, DateTime time, string description)
{
registrant = new ExerciseModel()
{
ActivityId = activityId, Username = username, Date = date, Time = time, Description = description
};
AddExercise();
}
public OneExercisePage(ExerciseModel model)
{
OneExerciseViewModel om = new OneExerciseViewModel(model);
base.Appearing += (o, e) => om.OnAppearing(o, e);
BindingContext = om;
InitializeComponent();
}
public ActionResult <ExerciseModel> PutExercise(long id, PutExerciseModel exercise)
{
var userName = User.Claims.Single(a => a.Type == ClaimTypes.NameIdentifier).Value;
var neededExercise = _context.Exercises.Include(i => i.Sets).First(i => i.Id == id);
if (neededExercise == null)
{
return(NotFound("Exercise not found"));
}
neededExercise.ExerciseType = exercise.Type;
neededExercise.Name = exercise.ExerciseName;
var sets = neededExercise.Sets.ToList();
foreach (var set in sets)
{
neededExercise.Sets.Remove(set);
}
foreach (var set in exercise.Sets)
{
if (set.Id == 0)
{
neededExercise.Sets.Add(new ExerciseSet
{
RepCount = set.RepCount,
Weight = set.Weights
});
}
else
{
neededExercise.Sets.Add(new ExerciseSet
{
Id = set.Id,
RepCount = set.RepCount,
Weight = set.Weights
});
}
}
_context.SaveChanges();
var returnExercise = _context.Exercises.Include(i => i.Sets).First(i => i.Id == id);
var returnExerciseTransformed = new ExerciseModel
{
Id = returnExercise.Id,
ExerciseName = returnExercise.Name,
Type = returnExercise.ExerciseType,
Sets = returnExercise.Sets.Select(i => new SetModel
{
Id = i.Id,
RepCount = i.RepCount,
Weights = i.Weight
}).ToList()
};
return(Ok(returnExerciseTransformed));
}
public void SaveExercise(ExerciseModel exercise, UserModel user)
{
// Is this a new exercise?
if (exercise.ExerciseId == 0)
{
String query = "INSERT INTO EXERCISES";
query += " (DS_ID, EX_NAME, EX_SUMMARY, EX_DESCRIPTION, EX_CREATED_DATE, EX_CREATED_BY, EX_DELETED, EX_SECTION_NAME, EX_ORDER, EX_SHOW_QUERY_BUILDER)";
query += " VALUES";
query += " (@DS_ID, @EX_NAME, @EX_SUMMARY, @EX_DESCRIPTION, GETDATE(), @CREATED_BY, 0, @EX_SECTION_NAME, isnull((SELECT MAX(EX_ORDER) + 1 FROM EXERCISES WHERE EX_SECTION_NAME = @EX_SECTION_NAME), 0), @EX_SHOW_QUERY_BUILDER)";
using (SqlConnection conn = new SqlConnection(Properties.Settings.Default.DatabaseConnectionString))
{
conn.Open();
using (SqlCommand command = new SqlCommand(query, conn))
{
command.Parameters.AddWithValue("DS_ID", exercise.DataSourceId);
command.Parameters.AddWithValue("EX_NAME", exercise.Name);
command.Parameters.AddWithValue("EX_SUMMARY", exercise.Summary);
command.Parameters.AddWithValue("EX_DESCRIPTION", exercise.Description);
command.Parameters.AddWithValue("CREATED_BY", user.Email);
command.Parameters.AddWithValue("EX_SECTION_NAME", exercise.SectionName);
command.Parameters.AddWithValue("EX_SHOW_QUERY_BUILDER", exercise.ShowQueryBuilder);
command.ExecuteNonQuery();
}
}
}
else
{
String query = "UPDATE EXERCISES";
query += " SET DS_ID = @DS_ID,";
query += " EX_NAME = @EX_NAME,";
query += " EX_SUMMARY = @EX_SUMMARY,";
query += " EX_DESCRIPTION = @EX_DESCRIPTION,";
query += " EX_UPDATED_DATE = GETDATE(),";
query += " EX_UPDATED_BY = @UPDATED_BY,";
query += " EX_SECTION_NAME = @EX_SECTION_NAME,";
query += " EX_SHOW_QUERY_BUILDER = @EX_SHOW_QUERY_BUILDER,";
query += " EX_ORDER = @EX_ORDER";
query += " WHERE EX_ID = @EX_ID";
using (SqlConnection conn = new SqlConnection(Properties.Settings.Default.DatabaseConnectionString))
{
conn.Open();
using (SqlCommand command = new SqlCommand(query, conn))
{
command.Parameters.AddWithValue("EX_ID", exercise.ExerciseId);
command.Parameters.AddWithValue("DS_ID", exercise.DataSourceId);
command.Parameters.AddWithValue("EX_NAME", exercise.Name);
command.Parameters.AddWithValue("EX_SUMMARY", exercise.Summary);
command.Parameters.AddWithValue("EX_DESCRIPTION", exercise.Description ?? "");
command.Parameters.AddWithValue("UPDATED_BY", user.Email);
command.Parameters.AddWithValue("EX_SECTION_NAME", exercise.SectionName);
command.Parameters.AddWithValue("EX_ORDER", exercise.Order);
command.Parameters.AddWithValue("EX_SHOW_QUERY_BUILDER", exercise.ShowQueryBuilder);
command.ExecuteNonQuery();
}
}
}
}
private async void OnItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (e.SelectedItem != null)
{
ExerciseModel model = (ExerciseModel)e.SelectedItem;
((ListView)sender).SelectedItem = null;
await Navigation.PushModalAsync(new OneExercisePage(model));
}
}
public IActionResult AddExercise(int templateId)
{
ExerciseModel model = new ExerciseModel()
{
TrainingTemplateId = templateId
};
return(View(model));
}
public void ExerciseUpdateComplete(ExerciseModel model)
{
int index = selectedExercises.IndexOf(selectedExercises.Find(x => x.Id == model.Id));
selectedExercises.Remove(selectedExercises.Find(x => x.Id == model.Id));
selectedExercises.Insert(index, model);
WireUpList();
}
public IActionResult Get(Guid id)
{
var exercise = exercises.Get(id);
if (exercise == null)
{
return(NotFound());
}
return(Ok(ExerciseModel.ToModel(exercise)));
}
public IActionResult PostExercise(Guid id, [FromBody] ExerciseModel exercise)
{
var newExercise = homeworks.AddExercise(id, ExerciseModel.ToEntity(exercise));
if (newExercise == null)
{
return(BadRequest());
}
return(CreatedAtRoute("GetExercise", new { id = newExercise.Id }, ExerciseModel.ToModel(newExercise)));
}
public ExerciseModel CreateViewModel(Exercise datamodel)
{
if (datamodel == null) { throw new ArgumentNullException("datamodel"); }
var result = new ExerciseModel()
{
Id = datamodel.Id,
Description = datamodel.Description,
Name = datamodel.Name,
Url = _UrlHelper.Link("GetExerciseById", new { id = datamodel.Id })
};
if (datamodel.Schedules != null && datamodel.Schedules.Any())
{
result.Schedules = datamodel.Schedules.Select(x => new EntryModel<int>()
{
Id = x.Id,
Name = x.Name,
Url = _UrlHelper.Link("GetScheduleById", new { id = x.Id })
});
}
return result;
}
/*public async Task DeleteRefreshtokenAsync(string tokenId)
{
await DeleteAsJsonAsync(new {tokenId}, "/api/RefreshTokens");
}*/
#endregion
#region Exercise
/// <summary>
/// Creates a new exercise
/// </summary>
/// <param name="model">exercise data</param>
/// <returns></returns>
public async Task<ExerciseModel> CreateExerciseAsync(ExerciseModel model)
{
return await this.PostAsJsonReturnAsync<ExerciseModel, ExerciseModel>(model, "/api/exercise");
}
public async Task<IHttpActionResult> CreateExercise(ExerciseModel exercise)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var datamodel = this.TheModelFactory.CreateModel(exercise);
await this.AppRepository.Exercise.AddAsync(datamodel);
exercise = this.TheModelFactory.CreateViewModel(datamodel);
return CreatedAtRoute("GetExerciseById", new { id = exercise.Id }, exercise);
}
/// <summary>
/// Updates an exercise
/// </summary>
/// <param name="id">Id of an exercise</param>
/// <param name="model">new exercise data</param>
/// <returns></returns>
public async Task UpdateExerciseAsync(int id, ExerciseModel model)
{
await PutAsJsonAsync(model, "api/exercise/" + id);
}
/*
/// <summary>
/// Gibt einen Trainingsplan zurück
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ScheduleModel> GetScheduleByIdAsync(int id)
{
if (Online)
{
try
{
ScheduleModel schedule = await mgnService.GetScheduleByIdAsync(id);
return schedule;
}
catch (ServerException ex)
{
System.Console.WriteLine("Fehler beim Online-Abrufen eines Trainingsplans: " + ex.StackTrace);
throw;
}
}
else
{
try
{
Schedule schedule = db.GetScheduleById(id);
ScheduleModel result = new ScheduleModel();
result.Id = schedule.Id;
result.Name = schedule.Name;
result.Url = schedule.Url;
result.UserId = schedule.UserId;
List<EntryModel<int>> temp = new List<EntryModel<int>>();
foreach (var item in db.GetAllExercisesBySchedule(result.Id))
{
EntryModel<int> e = new EntryModel<int>();
e.Id = item;
temp.Add(e);
}
result.Exercises = temp;
return result;
}
catch (Exception exc)
{
System.Console.WriteLine("Fehler beim lokalen Abrufen eines Trainingsplans: " + exc.StackTrace);
return null;
}
}
}*/
/// <summary>
/// Gibt die Übungen eines Trainingsplans zurück
/// </summary>
/// <param name="scheduleId"></param>
/// <returns></returns>
public async Task<List<ExerciseModel>> GetExercisesForSchedule(int scheduleId)
{
if (Online)
{
try
{
ScheduleModel schedule = await mgnService.GetScheduleByIdAsync(scheduleId);
IEnumerable<EntryModel<int>> scheduleExercises = schedule.Exercises;
List<ExerciseModel> result = new List<ExerciseModel>();
foreach (var exercise in scheduleExercises)
{
//Für jede zugewiesene Id die Exercise raussuchen und der IEnumerable hinzufügen
ExerciseModel temp = await mgnService.GetExerciseByIdAsync(exercise.Id);
result.Add(temp);
}
//Übernehmen der Exercises in die lokale DB
foreach (var item in result)
{
Exercise e = new Exercise();
e.Description = item.Description;
e.Id = item.Id;
e.Name = item.Name;
e.Url = item.Url;
e.WasOffline = false;
db.insertUpdateExercise(e);
//db.InsertScheduleHasExercises(scheduleId, e.Id, false);
}
return result;
}
catch (ServerException ex)
{
System.Console.WriteLine("Fehler beim Online-Abrufen der Übungen eines Trainingsplans: " + ex.StackTrace);
throw;
}
}
else
{
try
{
List<ExerciseModel> result = new List<ExerciseModel>();
//Anhand der scheduleId alle Exercises aus der ScheduleHasExercises-Tabelle holen
Schedule test = db.GetScheduleById(scheduleId);
List<Exercise> exercises = db.GetExercisesOfSchedule(scheduleId);
foreach (var item in exercises)
{
ExerciseModel e = new ExerciseModel();
e.Description = item.Description;
e.Name = item.Name;
e.Url = item.Name;
e.Id = item.Id;
List<EntryModel<int>> schedules = new List<EntryModel<int>>();
EntryModel<int> temp = new EntryModel<int>();
temp.Id = scheduleId;
schedules.Add(temp);
e.Schedules = schedules;
result.Add(e);
}
if(result.Count == 0)
{
Console.WriteLine("Keine Übungen zu dem Trainingsplan vorhanden");
return null;
}
return result;
}
catch (Exception exc)
{
System.Console.WriteLine("Fehler beim lokalen Abrufen eines Trainingsplans: " + exc.StackTrace);
return null;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="exerciseId"></param>
/// <returns></returns>
public async Task<ExerciseModel> GetExerciseByIdAsync(int exerciseId)
{
if (Online)
{
try
{
ExerciseModel exercise = await mgnService.GetExerciseByIdAsync(exerciseId);
Exercise insert = new Exercise();
insert.Id = exercise.Id;
insert.Name = exercise.Name;
insert.Url = exercise.Url;
insert.Description = exercise.Description;
db.insertUpdateExercise(insert);
return exercise;
}
catch (ServerException ex)
{
System.Console.WriteLine("Fehler beim Abrufen einer Übung: " + ex.StackTrace);
throw;
}
}
else
{
try
{
Exercise exercise = db.GetExerciseById(exerciseId);
ExerciseModel output = new ExerciseModel();
output.Id = exercise.Id;
output.Name = exercise.Name;
output.Url = exercise.Url;
output.Description = exercise.Description;
List<EntryModel<int>> temp = new List<EntryModel<int>>();
foreach (var item in db.GetAllSchedulesByExercise(output.Id))
{
EntryModel<int> e = new EntryModel<int>();
e.Id = item;
temp.Add(e);
}
output.Schedules = temp;
return output;
}
catch(Exception exc)
{
System.Console.WriteLine("Fehler beim lokalen Abrufen einer Übung: " + exc.StackTrace);
return null;
}
}
}
public Exercise CreateModel(ExerciseModel model, Exercise datamodel = null)
{
var result = datamodel ?? new Exercise();
result.Description = model.Description;
result.Name = model.Name;
result.Id = model.Id;
return result;
}
public async static Task createTestdata(IManagementSession session)
{
Guid userId = session.CurrentUserId;
ScheduleModel s = new ScheduleModel();
s.Name = "Arbeitstraining";
s.UserId = userId.ToString();
ScheduleModel back = await session.Users.CreateScheduleAsync(s);
Console.WriteLine("Schedule angelegt");
var e1 = new ExerciseModel()
{
Name = "Bankdrücken",
Description = "Stange von der Brust wegdrücken"
};
var e2 = new ExerciseModel()
{
Name = "Kniebeuge",
Description = "Ordentlich aus den Oberschnkeln drücken"
};
var e3 = new ExerciseModel()
{
Name = "Beinpresse",
Description = "Schweres Gewicht"
};
ExerciseModel temp1 = await session.Admins.CreateExerciseAsync(e1);
ExerciseModel temp2 = await session.Admins.CreateExerciseAsync(e2);
ExerciseModel temp3 = await session.Admins.CreateExerciseAsync(e3);
await session.Users.AddExerciseToScheduleAsync(back.Id, temp1.Id);
await session.Users.AddExerciseToScheduleAsync(back.Id, temp2.Id);
await session.Users.AddExerciseToScheduleAsync(back.Id, temp3.Id);
Console.WriteLine("Übungen hinzugefügt");
/*EntryModel<int> a1 = new EntryModel<int>();
a1.Id = temp1.Id;
exercises.Add(a1);
ExerciseModel temp2 = await session.Admins.CreateExerciseAsync(e2);
EntryModel<int> a2 = new EntryModel<int>();
a2.Id = temp2.Id;
exercises.Add(a2);
ExerciseModel temp3 = await session.Admins.CreateExerciseAsync(e3);
EntryModel<int> a3 = new EntryModel<int>();
a3.Id = temp3.Id;
exercises.Add(a3);
ScheduleModel sUpdate = back;
sUpdate.Exercises = exercises;
var t = session.Users.UpdateScheduleAsync(sUpdate.Id, sUpdate);
Console.WriteLine("Exercises angelegt");
/*PracticeModel p = new PracticeModel();
p.ExerciseId = temp1.Id;
p.ScheduleId = back.Id;
p.NumberOfRepetitions = 4;
p.Repetitions = 12;
p.Timestamp = DateTime.Now;
p.UserId = userId.ToString();
p.Weight = 120.9;
PracticeModel tempP = await session.Users.CreatePracticeAsync(p);
PracticeModel p2 = new PracticeModel();
p2.ExerciseId = temp2.Id;
p2.ScheduleId = back.Id;
p2.NumberOfRepetitions = 5;
p2.Repetitions = 15;
p2.Timestamp = DateTime.Now;
p2.UserId = userId.ToString();
p2.Weight = 40;
PracticeModel tempP2 = await session.Users.CreatePracticeAsync(p2);
Console.WriteLine("Practices angelegt");*/
}
