public ActionResult <Exercise> PostExercise(int id, ExerciseDTO exercise)
{
if (!_trainingsSchemaRepository.TryGetTrainingsSchema(id, out var trainingsSchema))
{
return(NotFound());
}
var exerciseToCreate = new Exercise(exercise.Name, exercise.Reps, exercise.Sets);
trainingsSchema.AddExercise(exerciseToCreate);
_trainingsSchemaRepository.SaveChanges();
return(CreatedAtAction("GetExercise", new { id = trainingsSchema.Id, exerciseId = exerciseToCreate.Id }, exerciseToCreate));
}
public void TestPublish_AlreadyPublished()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = SecurityManager.CreateNewSession(profile, ClientInformation);
ExerciseDTO exerciseDto = Mapper.Map <Exercise, ExerciseDTO>(exercises["t13"]);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
service.PublishExercise(data.Token, exerciseDto);
});
}
//public static bool CanBeFavorite(this ExerciseDTO exercise)
//{
// if (exercise == null || exercise.Profile == null || exercise.IsMine())
// {
// return false;
// }
// return true;
//}
public static bool IsEditable(this ExerciseDTO exercise)
{
if (exercise == null)
{
return(false);
}
if (exercise.Profile == null || exercise.Status != PublishStatus.Private)
{
return(false);
}
return(true);
}
public void TestPublish_ExerciseTypeNotSet()
{
var profile = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile, ClientInformation);
ExerciseDTO exerciseDto = Mapper.Map <Exercise, ExerciseDTO>(exercises["t23"]);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
service.PublishExercise(data.Token, exerciseDto);
});
Assert.AreEqual(PublishStatus.PendingPublish, Session.Get <Exercise>(exerciseDto.GlobalId).Status);
}
public ActionResult <ExerciseDTO> AddExercise(ExerciseDTO exercise)
{
if (exercise.IdExercise != 0)
{
trainingSevice.UpdateExercise(exercise);
}
else
{
trainingSevice.AddExercise(exercise);
}
return(Ok());
}
public async Task <Exercise> CreateAsync(ExerciseDTO exercise)
{
var newExercise = new Exercise
{
Name = exercise.Name,
Stage = exercise.Stage,
Muscle = exercise.Muscle
};
appDbContext.Exercises.Add(newExercise);
await appDbContext.SaveChangesAsync();
return(newExercise);
}
private List <ExerciseDTO> ConvertExercise(List <Exercise> exercises)
{
List <ExerciseDTO> exerciseDTOs = new List <ExerciseDTO>();
if (exercises != null)
{
foreach (var exercise in exercises)
{
ExerciseDTO exerciseDTO = new ExerciseDTO(exercise.ExerciseID, exercise.Name, exercise.UserID, (ExerciseTypeDTO)exercise.ExerciseType);
exerciseDTOs.Add(exerciseDTO);
}
}
return(exerciseDTOs);
}
internal static void UpdateExercise(ExerciseDTO exerciseDto, bool delete = false)
{
if (dictExercises.ContainsKey(exerciseDto.GlobalId))
{
if (delete)
{
dictExercises.Remove(exerciseDto.GlobalId);
}
else
{
dictExercises[exerciseDto.GlobalId] = exerciseDto;
}
}
}
public IActionResult PostExercise(Guid id, [FromBody] ExerciseDTO exerciseDTO)
{
Exercise exercise = exerciseDTO.ToEntity();
Exercise createdExercise = homeworksLogic.AddExercise(id, exercise);
if (createdExercise == null)
{
return(BadRequest());
}
ExerciseDTO exerciseToReturn = new ExerciseDTO(createdExercise);
return(CreatedAtRoute("GetExercise", new { id = exerciseToReturn.Id }, exerciseToReturn));
}
public void AddExercise(ExerciseDTO exercise)
{
using (SqlConnection connection = new SqlConnection(GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("INSERT INTO Exercises VALUES(@ExerciseID, @Name, @UserID, @ExerciseType)", connection);
cmd.Parameters.AddWithValue("@ExerciseID", exercise.ExerciseID);
cmd.Parameters.AddWithValue("@Name", exercise.Name);
cmd.Parameters.AddWithValue("@UserID", exercise.UserID);
cmd.Parameters.AddWithValue("@ExerciseType", exercise.ExerciseType);
connection.Open();
cmd.ExecuteNonQuery();
connection.Close();
}
}
public void OpenExercise(ExerciseDTO exercise)
{
if (exercise.GlobalId != Guid.Empty)
{
exercise = exercise.Clone();
}
AddExercise dlg = new AddExercise();
dlg.Fill(exercise);
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
OnFillReqest();
}
}
private static Exercise MapExerciseDTOToExercise(ExerciseDTO exerciseDTO)
{
return(new Exercise
{
Id = exerciseDTO.Id,
Title = exerciseDTO.Title,
Type = exerciseDTO.Type,
ImageUrl = exerciseDTO.ImageUrl,
CategoryId = exerciseDTO.CategoryId,
QuestionUrl = exerciseDTO.QuestionUrl,
VideoUrl = exerciseDTO.VideoUrl,
Level = exerciseDTO.Level,
Answers = MapAnswerDTOListToAnswerList(exerciseDTO.Answers)
});
}
private RoundDTO ConvertRoundVM(RoundViewModel roundViewModel)
{
List <SetDTO> sets = new List <SetDTO>();
foreach (var set in roundViewModel.Sets)
{
set.SetOrder = roundViewModel.Sets.IndexOf(set);
sets.Add(ConvertSetVM(set));
}
UserCollection userCollection = new UserCollection();
ExerciseDTO exercise = userCollection.GetExercise(roundViewModel.Exercise.Name);
RoundDTO round = new RoundDTO(exercise, exercise.ExerciseID, sets);
return(round);
}
public static void CleanUpTests()
{
IUserCollection userCollection = UserCollectionFactory.GetUserCollection();
ExerciseDTO tempDeadlift = userCollection.GetExercise("TempDeadlift");
ExerciseDTO tempSquat = userCollection.GetExercise("TempSquat");
ExerciseDTO tempPushup = userCollection.GetExercise("TempPushup");
ExerciseDTO tempLegPress = userCollection.GetExercise("TempLegpress");
ExerciseDTO tempLegextenstion = userCollection.GetExercise("TempLegextension");
userCollection.DeleteExercise(tempDeadlift.ExerciseID.ToString());
userCollection.DeleteExercise(tempSquat.ExerciseID.ToString());
userCollection.DeleteExercise(tempPushup.ExerciseID.ToString());
userCollection.DeleteExercise(tempLegPress.ExerciseID.ToString());
userCollection.DeleteExercise(tempLegextenstion.ExerciseID.ToString());
}
public void Fill(TrainingPlan plan)
{
SuperSetViewManager superSetManager = new SuperSetViewManager();
Clear();
Columns.Add("colExercise", StrengthTrainingEntryStrings.ExercisesTrainingPlanListView_ExerciseColumn, 200);
Columns.Add("colExerciseType", StrengthTrainingEntryStrings.ExercisesTrainingPlanListView_MuscleColumn);
for (int i = 0; i < plan.GetMaximumSeriesCount(); i++)
{
int setNumber = i + 1;
Columns.Add("colSet" + setNumber, string.Format(StrengthTrainingEntryStrings.ExercisesTrainingPlanListView_SetColumn, setNumber));
}
for (int i = 0; i < plan.Days.Count; i++)
{
TrainingPlanDay day = plan.Days[i];
ListViewGroup group = new ListViewGroup(string.IsNullOrEmpty(day.Name) ? StrengthTrainingEntryStrings.ExercisesTrainingPlanListView_EmptyDayName : day.Name);
Groups.Add(group);
bool alt = false;
foreach (var planEntry in day.Entries)
{
ExerciseDTO exercise = ObjectsReposidory.GetExercise(planEntry.ExerciseId);
ListViewItem item = new ListViewItem(new string[] { exercise.GetLocalizedName(), EnumLocalizer.Default.Translate(exercise.ExerciseType) });
if (alt && UseAlternateRows)
{
item.BackColor = Color.LightGray;
}
alt = !alt;
//get special color for superset entry
var superSet = day.GetSuperSet(planEntry);
if (superSet != null)
{
item.BackColor = superSetManager.GetSuperSetColor(superSet.SuperSetId.ToString());
}
item.Group = group;
Items.Add(item);
item.Tag = planEntry;
for (int j = 0; j < planEntry.Sets.Count; j++)
{
ListViewItem.ListViewSubItem subItem = new ListViewItem.ListViewSubItem();
item.SubItems.Add(subItem);
subItem.Text = planEntry.Sets[j].GetDisplayText();
subItem.Tag = planEntry.Sets[j];
}
}
}
}
public void UpdateExercise_SecurityBug()
{
var profile = (ProfileDTO)profiles[1].Tag;
var exercise = CreateExercise(Session, profiles[0], "ex1", "EE");
SessionData data = CreateNewSession(profile, ClientInformation);
ExerciseDTO exerciseDto = exercise.Map <ExerciseDTO>();
exerciseDto.Description = "new desc";
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
service.SaveExercise(data.Token, exerciseDto);
});
}
public void AddExercise_Correctly()
{
//arrange
IUserCollection userCollection = UserCollectionFactory.GetUserCollection();
IUser user = UserFactory.GetUser();
ExerciseDTO legpress = new ExerciseDTO("TempLegpress", userID, ExerciseTypeDTO.Weighted);
//act
user.AddExercise(legpress);
//assert
ExerciseDTO legpressDTO = userCollection.GetExercise("TempLegpress");
Assert.AreEqual("TempLegpress", legpressDTO.Name);
Assert.AreEqual(ExerciseTypeDTO.Weighted, legpressDTO.ExerciseType);
Assert.AreEqual(userID, legpressDTO.UserID);
}
public void TestVoteExercise_Global_DontSendMessage()
{
//var profile = (ProfileDTO)profiles[0].Tag;
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
ExerciseDTO dto = Mapper.Map <Exercise, ExerciseDTO>(exercises["global"]);
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteExercise(data.Token, dto);
});
var count = Session.QueryOver <Message>().RowCount();
Assert.AreEqual(0, count);
}
public void TestVoteExercise_Statistics()
{
//var profile = (ProfileDTO)profiles[0].Tag;
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
ExerciseDTO dto = Mapper.Map <Exercise, ExerciseDTO>(exercises["t"]);
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteExercise(data.Token, dto);
});
var dbProfile = Session.Get <Profile>(profile1.Id);
Assert.AreEqual(1, dbProfile.Statistics.VotingsCount);
}
StrengthTrainingItemDTO createStrengthTrainingItem(ExerciseType exerciseType, params string[] sets)
{
ExerciseDTO exercise = new ExerciseDTO();
exercise.ExerciseType = exerciseType;
StrengthTrainingItemDTO item = new StrengthTrainingItemDTO();
item.Exercise = exercise;
foreach (var serie in sets)
{
SerieDTO set = new SerieDTO(serie);
item.AddSerie(set);
}
return(item);
}
public void Fill(ExerciseDTO exercise, IEnumerable <ExerciseDTO> exercises)
{
this.exercise = exercise;
setReadOnly();
Url = exercise.GetLocalizedUrl();
Description = exercise.GetLocalizedDescription();
ExerciseName = exercise.GetLocalizedName();
Shortcut = exercise.GetLocalizedShortcut();
ExerciseType = exercise.ExerciseType;
Mechanics = exercise.MechanicsType;
Force = exercise.ExerciseForceType;
Met = exercise.Met;
Difficult = (double)exercise.Difficult;
if (exercises != null)
{
this.exercises = exercises;
}
}
public void Get_Exercise_By_ID()
{
//arrange
IUser user = UserFactory.GetUser();
IExerciseDAL dal = ExerciseDALFactory.GetExerciseDAL();
ExerciseDTO tempExercise = new ExerciseDTO(Guid.NewGuid(), "TempSquat", userID, ExerciseTypeDTO.Weighted);
dal.AddExercise(tempExercise);
//act
ExerciseDTO exerciseDTO = user.GetExercise(tempExercise.ExerciseID.ToString());
//assert
Assert.AreEqual("TempSquat", exerciseDTO.Name);
Assert.AreEqual(tempExercise.ExerciseID, exerciseDTO.ExerciseID);
Assert.AreEqual(ExerciseTypeDTO.Weighted, exerciseDTO.ExerciseType);
Assert.AreEqual(userID, exerciseDTO.UserID);
}
public async Task <bool> UpdateAsync(int id, ExerciseDTO exercise)
{
var exerciseToUpdate = await appDbContext.Exercises.FindAsync(id);
if (exerciseToUpdate == null)
{
return(false);
}
exerciseToUpdate.Name = exercise.Name;
exerciseToUpdate.Stage = exercise.Stage;
exerciseToUpdate.Muscle = exercise.Muscle;
appDbContext.Entry(exerciseToUpdate).State = EntityState.Modified;
await appDbContext.SaveChangesAsync();
return(true);
}
private void rbtnNew_Click(object sender, RoutedEventArgs e)
{
//ExerciseEditorWindow dlg = new ExerciseEditorWindow();
//var newExercise = new ExerciseDTO();
//if (SelectedExerciseType.HasValue)
//{
// newExercise.ExerciseType = SelectedExerciseType.Value;
//}
//else if(SelectedExercise!=null)
//{
// newExercise.ExerciseType = SelectedExercise.ExerciseType;
//}
//dlg.Fill(newExercise);
//if(dlg.ShowDialog()==true)
//{
// Fill();
//}
if (!UIHelper.EnsurePremiumLicence())
{
return;
}
var dlg = new EditDomainObjectWindow();
var ctrl = new usrExerciseEditor();
var newExercise = new ExerciseDTO();
if (SelectedExerciseType.HasValue)
{
newExercise.ExerciseType = SelectedExerciseType.Value;
}
else if (SelectedExercise != null)
{
newExercise.ExerciseType = SelectedExercise.ExerciseType;
}
ctrl.Fill(newExercise, ExercisesReposidory.Instance.Items.Values);
dlg.SetControl(ctrl);
if (dlg.ShowDialog() == true)
{
ExercisesReposidory.Instance.Add((ExerciseDTO)ctrl.Object);
Fill(pageContext);
}
}
private object GetValue(ExerciseParamType par, ExerciseDTO exercise)
{
switch (par.ParamName.ToString())
{
case "ExerciseName":
return(exercise.ExerciseName);
case "Note":
return(exercise.Note);
case "SeriesCount":
return(exercise.SeriesCount);
case "Distance":
return(exercise.Distance);
case "Time":
return(exercise.Time);
case "Spikes":
return(exercise.Spikes);
case "ExerciseCount":
return(exercise.ExerciseCount);
case "Weight":
return(exercise.Weight);
case "IdJumpType":
return(exercise.JumpType);
case "Height":
return(exercise.Height);
case "StepsCount":
return(exercise.StepsCount);
case "IdPole":
return(exercise.IdPole);
default:
return("");
}
}
public async Task <IActionResult> PostExercise([FromRoute] int?userId, [FromBody] ExerciseDTO exerciseDTO)
{
if (userId == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!await _repository.UserExists(userId))
{
return(NotFound("User Doesn't Exist"));
}
exerciseDTO.WTUserID = userId;
var exerciseEntity = Mapper.Map <Exercise>(exerciseDTO);
var result = await _repository.AddExerciseForUser(userId, exerciseEntity);
if (result == false)
{
return(BadRequest("Add Failed..."));
}
if (exerciseEntity.ImageBytes != null && exerciseEntity.ImageBytes.Length != 0)
{
var imageResult = await SaveExerciseImage(exerciseEntity);
}
var exerciseToReturn = Mapper.Map <ExerciseDTO>(exerciseEntity);
return(CreatedAtRoute(
routeName: "GetExercise",
routeValues: new
{
userId = userId,
exerciseId = exerciseToReturn.ID
},
value: exerciseToReturn));
}
public async Task <IList <ExerciseDTO> > AddExerciseToWorkoutAsync(ExerciseDTO exerciseDTO)
{
var existentExercises = await _exerciseRepository.GetByWorkoutIdAsync(exerciseDTO.WorkoutId);
var order = -1;
if (existentExercises.Count > 0)
{
order = existentExercises.Select(x => x.Order).LastOrDefault();
}
var exerciseToAdd = new Exercise {
Order = ++order, ExerciseTemplateId = exerciseDTO.ExerciseTemplateId, WorkoutId = exerciseDTO.WorkoutId
};
await _exerciseRepository.AddAsync(exerciseToAdd);
return(await GetExercisesFromWorkoutAsync(exerciseDTO.WorkoutId));
}
public ActionResult <Exercise> CreateExercise([FromBody] ExerciseDTO model, string gymnastEmail)
{
var gymnast = _gymnasts.GetByEmail(gymnastEmail);
if (gymnast == null)
{
return(NotFound("Geen gymnast met deze email"));
}
try {
Exercise newExercise = new Exercise(model.Description, "", gymnast);
_exercises.Add(newExercise);
_exercises.SaveChanges();
return(Ok(newExercise));
} catch (Exception e) {
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
public void Get_Exercise_By_Name()
{
//arrange
IUserCollection userCollection = UserCollectionFactory.GetUserCollection();
IExerciseDAL dal = ExerciseDALFactory.GetExerciseDAL();
Guid exerciseID = Guid.NewGuid();
ExerciseDTO tempExercise = new ExerciseDTO(exerciseID, "TempDeadlift", userID, ExerciseTypeDTO.Weighted);
dal.AddExercise(tempExercise);
//act
ExerciseDTO TempDeadliftDTO = userCollection.GetExercise("TempDeadlift");
//assert
Assert.AreEqual("TempDeadlift", TempDeadliftDTO.Name);
Assert.AreEqual(exerciseID, TempDeadliftDTO.ExerciseID);
Assert.AreEqual(ExerciseTypeDTO.Weighted, TempDeadliftDTO.ExerciseType);
Assert.AreEqual(userID, TempDeadliftDTO.UserID);
}
public void TestVoteExercise_DisableSendMessage()
{
profiles[0].Settings.NotificationExerciseVoted = false;
insertToDatabase(profiles[0]);
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
ExerciseDTO dto = Mapper.Map <Exercise, ExerciseDTO>(exercises["t"]);
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteExercise(data.Token, dto);
});
var messages = Session.QueryOver <Message>().Where(x => x.Receiver == profiles[0] && x.MessageType == MessageType.ExerciseVoted).SingleOrDefault();
Assert.IsNull(messages);
}
