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");*/ }