public IActionResult UpdateExercise(ExerciseDto exerciseDto)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("UpdateExercise", "bdbusr", new { id = exerciseDto.Id }));
}
var exercise = _utilities.MapExerciseDtoToExercise(exerciseDto);
//var exercise = _workoutRepository.GetExercise(exerciseDto.Id);
//if (exercise == null)
// return RedirectToAction("UpdateExercise", "Exercise", new { id = exerciseDto.Id });
//exercise.Name = exerciseDto.Name;
//exercise.Type = exerciseDto.Type;
_workoutRepository.ModifyExercise(exercise);
if (!_workoutRepository.Save())
{
return(RedirectToAction("UpdateExercise", "bdbusr", new { id = exerciseDto.Id }));
}
return(RedirectToAction("ViewExercise", "bdbusr", new { id = exerciseDto.Id }));
}
public async Task <IActionResult> Post([FromBody] ExerciseDto exercise)
{
var exerciseEntity = _mapper.Map <Exercise>(exercise);
var category = await _activityContext.Set <ActivityType>()
.FindAsync(exercise.Activity);
var muscles = await _activityContext.Set <MuscleGroup>()
.Where(x => exercise.Muscles.Contains(x.Id))
.ToListAsync();
var equipment = await _activityContext.Set <Equipment>()
.Where(x => exercise.Equipment.Contains(x.Id))
.ToListAsync();
// TODO: validate if not null
exerciseEntity.Category = category;
exerciseEntity.MuscleGroups = muscles;
exerciseEntity.Equipment = equipment;
_activityContext.Set <Exercise>().Add(exerciseEntity);
await _activityContext.SaveChangesAsync();
return(CreatedAtAction(nameof(Get), new { id = exerciseEntity.Id }));
}
public async Task <ExerciseDto> PeformExerciseAsync(int userId)
{
ExerciseDto exerciseDto = await GetExerciseAsync(userId);
if (exerciseDto is null)
{
return(null);
}
ActiveTraining activeTraining = (await userRepository.GetByIdAsync(userId)).ActiveTraining;
activeTraining.ExerciseDonePosition++;
await activeTrainingRepository.UpdateAsync(activeTraining);
ExerciseHistoryDto exerciseHistoryDto =
await exerciseHistoryService.AddExerciseHistoryAsync(exerciseDto.Id, userId);
if (exerciseHistoryDto is null)
{
return(null);
}
return(exerciseDto);
}
public Exercise MapExerciseDtoToExercise(ExerciseDto exerciseDto)
{
var exercise = _workoutRepository.GetExercise(exerciseDto.Id);
exercise.Name = exerciseDto.Name;
exercise.Type = exerciseDto.Type;
return(exercise);
}
public Exercise MapExerciseDtoToNewExercise(ExerciseDto exerciseDto)
{
var exercise = new Exercise();
exercise.Name = exerciseDto.Name;
exercise.Type = exerciseDto.Type;
return(exercise);
}
public ExerciseDto MapExerciseToExerciseDto(Exercise exercise)
{
var exerciseDto = new ExerciseDto();
exerciseDto.Id = exercise.Id;
exerciseDto.Name = exercise.Name;
exerciseDto.Type = exercise.Type;
return(exerciseDto);
}
public async Task <ExerciseDto> CreateExercise(ExerciseDto exerciseDto)
{
var exercise = _mapper.Map <Exercise>(exerciseDto);
var result = await _context.Exercises.AddAsync(exercise);
await _context.SaveChangesAsync();
var dto = _mapper.Map <ExerciseDto>(exercise);
return(dto);
}
public ExerciseDtoBuilder()
{
var random = new Random();
_dto = new ExerciseDto
{
CourseCode = Guid.NewGuid().ToString(),
ChapterNumber = random.NextPositive(),
ExerciseCode = Guid.NewGuid().ToString()
};
}
public async Task GetAllExercisesReturnsExerciseDtos()
{
//Arrage
var repositoryMock = new Mock <IExerciseRepository>();
var loggerMock = new Mock <ILoggerFactory>();
var mapperMock = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
var foundExercises = new List <Exercise>
{
new Exercise
{
Id = 0,
Name = "Bench",
Description = "Compound",
WorkoutEntries = new List <WorkoutEntry>()
},
new Exercise
{
Id = 1,
Name = "Squad",
Description = "Compound",
WorkoutEntries = new List <WorkoutEntry>()
}
};
var dto = new ExerciseDto
{
Id = 0,
Name = "Bench",
Description = "Compound"
};
mapperMock.Setup(m => m.Map <ExerciseDto>(It.IsAny <Exercise>())).Returns(dto);
repositoryMock.Setup(r => r.GetAllAsync()).ReturnsAsync(foundExercises.AsQueryable);
var SUT = new ExerciseService(loggerMock.Object, mapperMock.Object, repositoryMock.Object);
//Act
var result = await SUT.GetAllExercisesAsync();
//Assert
Assert.True(result.Count == 2);
}
public IHttpActionResult GetExercise(int exerciseId)
{
var userId = User.Identity.GetUserId();
var exercise = _unitOfWork.Exercises.GetExercise(exerciseId);
if (exercise.IsRemoved)
{
return(NotFound());
}
var exerciseDto = new ExerciseDto
{
Exercise = exercise,
};
return(Ok(exerciseDto));
}
public async Task <ExerciseDto> UpdateExercise(int id, ExerciseDto exerciseDto)
{
var exercise = await GetByIdAsync(id);
if (exercise == null)
{
return(null);
}
exerciseDto.Id = id;
exercise = _mapper.Map <Exercise>(exerciseDto);
_context.Exercises.Update(exercise);
await _context.SaveChangesAsync();
var dto = _mapper.Map <ExerciseDto>(exercise);
return(dto);
}
public async Task GetForTournament_1_ExerciseId_1()
{
//Arrange
var exercise = new ExerciseDto()
{
Id = 1,
Text = "1+1",
Answer = "2",
OrderNumber = 1,
TournamentId = 1
};
//Act
var tournamentExercises = await _exerciseRepository.GetForTournament(1);
//Assert
Assert.NotNull(tournamentExercises);
Assert.Contains(exercise.Text, tournamentExercises.Select(e => e.Text).ToList());
}
public async Task <IActionResult> Update([FromBody] ExerciseDto exercise)
{
if (exercise == null || exercise.Id == default)
{
return(BadRequest());
}
var exerciseEntity = await _activityContext.Set <Exercise>().FindAsync(exercise.Id);
if (exerciseEntity == null)
{
return(NotFound(new { id = exercise.Id }));
}
exerciseEntity.Name = exercise.Name;
exerciseEntity.Description = exercise.Description;
await _activityContext.Set <ActivityType>().LoadAsync();
if (exercise.Activity != exerciseEntity.Category.Id)
{
var category = await _activityContext.Set <ActivityType>().FindAsync(exercise.Activity);
exerciseEntity.Category = category;
}
var muscles = await _activityContext.Set <MuscleGroup>()
.Where(x => exercise.Muscles.Contains(x.Id))
.ToListAsync();
exerciseEntity.MuscleGroups = muscles;
var equipment = await _activityContext.Set <Equipment>()
.Where(x => exercise.Equipment.Contains(x.Id))
.ToListAsync();
exerciseEntity.Equipment = equipment;
await _activityContext.SaveChangesAsync();
return(Ok(new { id = exerciseEntity.Id }));
}
public async Task <IActionResult> AddAsync([FromBody] ExerciseDto exercise, [FromServices] IExerciseApplicationService service)
{
try
{
var registeredExercise = await service.AddAsync(exercise);
return(CreatedAtRoute(nameof(GetExerciseByIdAsync), new { id = registeredExercise.Id }, registeredExercise));
}
catch (Application.Exceptions.ApplicationException ex)
{
return(BadRequest(ex.ToResult()));
}
catch (ArgumentException ex)
{
return(BadRequest(new { reason = ex.Message }));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(Problem("Something is not right, calm down calm down! We're working to fix...(I hope so!"));
}
}
public async Task Get_id1includeExercise_NewTournamentWithExercise()
{
//Arrange
var exercise = new ExerciseDto()
{
Id = 1,
Text = "1+1",
Answer = "2",
OrderNumber = 1,
TournamentId = 1
};
//Act
var tournament = await _tournamentRepository.Get(1, "Exercises");
//Assert
Assert.NotNull(tournament);
Assert.NotNull(tournament.Exercises);
Assert.AreEqual("New Tournament", tournament.Caption);
Assert.Greater(tournament.Exercises.Count, 0);
Assert.Contains(exercise.Text, tournament.Exercises.Select(e => e.Text).ToList());
}
public async Task <IActionResult> PostExercise([FromBody] ExerciseDto exercise)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newExercise = new Exercise
{
Name = exercise.Name,
Sets = exercise.Sets,
Repetitions = exercise.Repetitions.GetValueOrDefault(),
Description = exercise.Description,
IsRepetition = exercise.IsRepetition,
Time = exercise.Time.GetValueOrDefault()
};
_context.Exercises.Add(newExercise);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetExercise", new { id = exercise.Id }, exercise));
}
public async Task <Exercise> GetOrCreateExerciseAsync(ExerciseDto exerciseDto)
{
var chapter = await _chapterService.GetOrCreateChapterAsync(exerciseDto.CourseCode, exerciseDto.ChapterNumber);
Exercise exercise;
try
{
exercise = await _exerciseRepository.GetSingleAsync(chapter.Id, exerciseDto.ExerciseCode);
}
catch (DataNotFoundException)
{
exercise = new Exercise
{
ChapterId = chapter.Id,
Code = exerciseDto.ExerciseCode
};
exercise = await _exerciseRepository.AddAsync(exercise);
}
return(exercise);
}
public IActionResult CreateExercise(ExerciseDto exerciseDto)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("CreateExercise", "bdbusr"));
}
var exercise = _utilities.MapExerciseDtoToNewExercise(exerciseDto);
//var exercise = new Exercise();
//exercise.Name = exerciseDto.Name;
//exercise.Type = exerciseDto.Type;
_workoutRepository.AddExercise(exercise);
if (!_workoutRepository.Save())
{
return(RedirectToAction("CreateExercise", "bdbusr"));
}
return(RedirectToAction("ViewExercise", "bdbusr", new { id = exercise.Id }));
}
private ExerciseDto GetExercise(string exerciseUrl)
{
var document = this.context.OpenAsync(exerciseUrl).GetAwaiter().GetResult();
var exercise = new ExerciseDto();
var exerciseName = document.QuerySelector("#js-ex-content > div > section.ExDetail-section.ExDetail-meta.flexo-container.flexo-start.flexo-between > div.grid-8.grid-12-s.grid-12-m > h1");
if (exerciseName != null)
{
exercise.Name = exerciseName.TextContent.Trim();
}
var exerciseDescription = document.QuerySelector("#js-ex-content > div > section.ExDetail-section.ExDetail-meta.flexo-container.flexo-start.flexo-between > div.ExDetail-shortDescription.grid-10 > p");
if (exerciseDescription != null)
{
exercise.Description = exerciseDescription.TextContent.Trim();
}
var benefits = document.QuerySelector("#js-ex-content > div > section.ExDetail-section.ExDetail-meta.flexo-container.flexo-start.flexo-between > div.ExDetail-benefits.grid-8 > ol");
if (benefits != null)
{
var listBenefits = benefits.TextContent.Trim().Split('\n');
var sb = new StringBuilder();
foreach (var benefit in listBenefits)
{
sb.AppendLine(benefit);
}
exercise.Benefits = sb.ToString().TrimEnd();
}
var properties = document.QuerySelectorAll(".bb-list--plain > li");
int count = 0;
foreach (var item in properties)
{
var curent = item.TextContent.Trim().Split(new string[] { "\n", ":\n", " " }, StringSplitOptions.RemoveEmptyEntries).ToArray();
if (count == 0 && curent != null)
{
if (curent.Length == 2)
{
exercise.ExerciseType = curent[1];
}
else
{
exercise.ExerciseType = curent[1] + curent[2];
}
}
else if (count == 1 && curent != null)
{
if (curent.Length == 4)
{
exercise.BodyPart = curent[3];
}
else
{
exercise.BodyPart = curent[3] + curent[4];
}
}
else if (count == 2 && curent != null)
{
exercise.EquipmentName = curent[1];
}
else if (count == 3 && curent != null)
{
exercise.Difficulty = curent[1];
}
count++;
}
var imageUrl = document.QuerySelector("#js-ex-content > div > section.ExDetail-section.ExDetail-photos.paywall__xdb-details > div.flexo-container.flexo-around.flexo-no-wrap > div:nth-child(1) > img").GetAttribute("src");
if (imageUrl != null)
{
exercise.ImageUrl = imageUrl;
}
return(exercise);
}
public CreateExerciseTestRunModelBuilder WithExercise(ExerciseDto exerciseDto)
{
Model.Exercise = exerciseDto;
return(this);
}
