public int StartWorkout(WorkoutPlan WorkoutPlan)
{
WorkoutService workoutManager = new WorkoutService();
int workoutId = workoutManager.StartWorkout(WorkoutPlan);
return(workoutId);
}
public Workout GetWorkoutById(int WorkoutId)
{
WorkoutService workoutManager = new WorkoutService();
Workout workout = workoutManager.GetWorkoutById(WorkoutId);
return(workout);
}
public WorkoutPlan GetWorkoutPlanById(int WorkoutPlanId)
{
WorkoutService workoutManager = new WorkoutService();
WorkoutPlan workoutPlan = workoutManager.GetWorkoutPlanById(WorkoutPlanId);
return(workoutPlan);
}
public Workout GetInProgressWorkoutByClientId(int ClientId)
{
WorkoutService workoutManager = new WorkoutService();
Workout workout = workoutManager.GetInProgressWorkoutByClientId(ClientId);
return(workout);
}
public List <WorkoutPlan> GetInactiveWorkoutPlansByClientId(int ClientId)
{
WorkoutService workoutManager = new WorkoutService();
List <WorkoutPlan> workoutPlans = workoutManager.GetInactiveWorkoutPlansByClientId(ClientId);
return(workoutPlans);
}
public List <Workout> GetCompletedWorkoutsByClientId(int ClientId)
{
WorkoutService workoutManager = new WorkoutService();
List <Workout> workouts = workoutManager.GetCompletedWorkoutsByClientId(ClientId);
return(workouts);
}
public Benchmarks(DataInitFixture fixture, ITestOutputHelper output)
{
//Initialize the output
this._output = output;
//Initialize DbContext in memory
this._fixture = fixture;
var builder =
new ConfigurationBuilder()
.AddJsonFile("testsettings.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
this._apibaseUrl = Configuration["AAD:Url"];
//Create the all services
_svcBenchmark = new BenchmarkService(_fixture.Context);
_svcAuth = new AuthService(_fixture.Context);
_svcMsg = new MessageService(_fixture.Context);
_svcPlayerResponse = new PlayerResponseService(_fixture.Context);
_svcPractice = new PracticeService(_fixture.Context);
_svcQuestionnaire = new QuestionnaireService(_fixture.Context);
_svcSession = new SessionService(_fixture.Context);
_svcCognitive = new CognitiveService(_fixture.Context);
_svcDrill = new DrillService(_fixture.Context);
_svcSettings = new SettingsService(_fixture.Context);
_svcTeam = new TeamService(_fixture.Context);
_svcWorkout = new WorkoutService(_fixture.Context);
}
private bool SetStarState(int workoutId, bool newState)
{
// Create the service
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutService(userId);
// Get the workout
var detail = service.GetWorkoutById(workoutId);
// Create the WorkoutEdit model instance with the new star state
var updatedWorkout =
new WorkoutEdit
{
WorkoutId = detail.WorkoutId,
NameOfWorkout = detail.NameOfWorkout,
IsStarred = newState,
TrainerId = detail.TrainerId,
ExerciseId = detail.ExerciseId,
Day = detail.Day,
Duration = detail.Duration,
DayOfWorkout = detail.DayOfWorkout
};
// Return a value indicating whether the update succeeded
return(service.UpdateWorkout(updatedWorkout));
}
public async Task SaveNewWorkoutNullReturnMinusOne()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
mockMapper.Setup(m => m.Map <WorkoutEntry>(It.IsAny <NewWorkoutEntryDto>())).Returns(new WorkoutEntry());
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.AddWorkoutAsync(null);
//Asert
Assert.True(result == -1);
}
public async Task DeleteWorkoutEntryInvalidUserIdReturnFalse()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
const int userId = -1;
const int entryId = 1;
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.DeleteWorkoutEntryAsync(userId, entryId);
//Asert
Assert.False(result);
}
public async Task DeleteWorkoutUserDatabaseCalledOnceOthersNever()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
const int userId = 1;
const int workoutid = 1;
userRepoMock.Setup(r => r.GetUser(It.IsAny <int>())).ReturnsAsync((User)null);
workoutRepoMock.Setup(r => r.DeleteAsync(It.IsAny <int>())).ReturnsAsync(true);
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.DeleteWorkoutAsync(userId, workoutid);
//Asert
userRepoMock.Verify(r => r.GetUser(It.IsAny <int>()));
Times.Once();
workoutRepoMock.Verify(r => r.DeleteAsync(It.IsAny <int>()), Times.Never);
}
private WorkoutService CreateWorkoutService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutService(userId);
return(service);
}
public ClientsController()
{
db = new ApplicationDbContext();
userStore = new UserStore <ApplicationUser>(db);
userManager = new ApplicationUserManager(userStore);
workoutService = new WorkoutService(db);
}
public async Task GetAllWorkoutNoneExistingUserReturnsNull()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
var userId = 1;
userRepoMock.Setup(r => r.FindAsync(It.IsAny <int>())).ReturnsAsync((User)null);
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.GetAllWorkoutsAsync(userId);
//Asert
Assert.Null(result);
}
async Task AddExercise()
{
try
{
if (Workout.WorkoutExercises.Count() > 0)
{
var lastOrder = Workout.WorkoutExercises.Max(w => w.OrderInt);
ExerciseToAdd.OrderInt = lastOrder + 1;
}
else
{
ExerciseToAdd.OrderInt = 1;
}
var response = await WorkoutService.AddExerciseToWorkoutAsync(Workout.Id, ExerciseToAdd);
if (response.IsSuccessStatusCode)
{
//Workout = await woService.GetWorkoutByIdAsync(WorkoutId);
await OnInitializedAsync();
ExerciseToAdd = new WorkoutExerciseModel();
}
else
{
Message = await response.Content.ReadAsStringAsync();
}
}
catch (Exception)
{
throw;
}
}
private void SeedWorkouts(ApplicationDbContext context)
{
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new ApplicationUserManager(userStore);
var exerciseTypeService = new ExerciseTypeService(context);
var workoutService = new WorkoutService(context);
// adding Workouts
var applicationUsers = new List <ApplicationUser>(userManager.Users);
foreach (var u in applicationUsers)
{
for (int i = 0; i < 90; i++)
{
var workout = new Workout();
if (i % 2 == 0)
{
workout = GetPreparedWorkoutTemplate1(u, exerciseTypeService);
}
else
{
workout = GetPreparedWorkoutTemplate2(u, exerciseTypeService);
}
workout.WorkoutDate = DateTime.Today.AddDays(-(i * 4));
workoutService.Create(workout);
}
}
}
public WorkoutController(FitnessCenterDbContext context, IMapper mapper)
{
_context = context;
_mapper = mapper;
_workourService = new WorkoutService(_context, _mapper);
_authenticationService = new AuthenticationService(_context);
}
public async Task SaveNewWorkoutNullDatabasesNotCalled()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
mockMapper.Setup(m => m.Map <WorkoutEntry>(It.IsAny <NewWorkoutEntryDto>())).Returns(new WorkoutEntry());
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.AddWorkoutAsync(null);
//Asert
userRepoMock.Verify(r => r.FindAsync(It.IsAny <int>()), Times.Never);
userRepoMock.Verify(r => r.UpdateAsync(It.IsAny <User>()), Times.Never);
workoutRepoMock.Verify(r => r.CreateAsync(It.IsAny <Workout>()), Times.Never);
exerciseRepoMock.Verify(r => r.FindAsync(It.IsAny <int>()), Times.Never);
}
public async Task DeleteWorkoutReturnsTrue()
{
//Arrange
var loggerMock = new Mock <ILoggerFactory>();
var userRepoMock = new Mock <IUserRepository>();
var workoutRepoMock = new Mock <IWorkoutRepository>();
var workoutEntryRepoMock = new Mock <IWorkoutEntryRepository>();
var exerciseRepoMock = new Mock <IExerciseRepository>();
var mockMapper = new Mock <IMapper>();
var logger = new Mock <ILogger>();
loggerMock.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
const int userId = 1;
const int workoutid = 1;
userRepoMock.Setup(r => r.GetUser(It.IsAny <int>())).ReturnsAsync(new User());
workoutRepoMock.Setup(r => r.DeleteAsync(It.IsAny <int>())).ReturnsAsync(true);
var SUT = new WorkoutService(loggerMock.Object, mockMapper.Object, userRepoMock.Object,
workoutRepoMock.Object,
exerciseRepoMock.Object, workoutEntryRepoMock.Object);
//Act
var result = await SUT.DeleteWorkoutAsync(userId, workoutid);
//Asert
Assert.True(result);
}
public WorkoutType(WorkoutService workoutService)
{
Field(o => o.Id);
Field <ListGraphType <WorkoutExerciseType>, IEnumerable <Exercise> >()
.Name("exercises")
.Resolve(ctx => workoutService.GetWorkoutAsync(ctx.Source.Id).Result.Exercises.Select(x => new WorkoutExerciseDto(x)));
}
// GET: Yoga
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutService(userId);
var model = service.GetWorkouts();
return(View(model));
}
public IHttpActionResult Get()
{
WorkoutService wService = CreateWorkoutService();
var content = wService.GetAllWorkout();
return(Ok(content));
}
public WorkoutsController()
{
db = new ApplicationDbContext();
userStore = new UserStore <ApplicationUser>(db);
userManager = new ApplicationUserManager(userStore);
exerciseTypeService = new ExerciseTypeService(db);
workoutService = new WorkoutService(db);
}
public IHttpActionResult GetByName(string workoutName)
{
WorkoutService wService = CreateWorkoutService();
var content = wService.GetWorkoutByName(workoutName);
return(Ok(content));
}
public IHttpActionResult GetByID(int workoutID)
{
WorkoutService wService = CreateWorkoutService();
var content = wService.GetWorkoutbyID(workoutID);
return(Ok(content));
}
public GoalsController(WorkoutService service,
UserManager <ApplicationUser> userService,
IAuthorizationService authService)
{
_service = service;
_userService = userService;
_authService = authService;
}
public void Should_Update_Workout()
{
//ARRANGE
//TODO: Create builder for these Workouts
var modifiedWorkout =
new Workout
{
Id = 1,
Exercises =
new List <ExerciseInWorkout>(2)
{
new ExerciseInWorkout
{
Id = 1
},
new ExerciseInWorkout
{
Id = 2
}
}
};
var existingWorkout =
new Workout
{
Id = 1,
Exercises =
new List <ExerciseInWorkout>(2)
{
new ExerciseInWorkout
{
Id = 1
},
new ExerciseInWorkout
{
Id = 3
}
}
};
var repoMock = new Mock <IRepository <Workout> >(MockBehavior.Strict);
repoMock
.Setup(mock => mock.UpdateAsync <Workout>(modifiedWorkout, It.IsAny <Expression <Func <Workout, object> >[]>()))
.Returns(Task.FromResult(existingWorkout.Id));
repoMock
.Setup(mock => mock.SetValues(existingWorkout, modifiedWorkout));
var sut = new WorkoutService(repoMock.Object);
//ACT
var result = sut.Update(modifiedWorkout, true);
//ASSERT
result.ShouldBeSameAs(modifiedWorkout);
repoMock.Verify(mock => mock.UpdateAsync(modifiedWorkout, It.IsAny <Expression <Func <Workout, object> >[]>()), Times.Once);
}
public void Constructor_ShouldCreateCorrectServiceWhenAllParametersAreValid()
{
var workoutsRepoStub = new Mock <IEfRepostory <Workout> >();
var unitOfWorkStub = new Mock <IUnitOfWork>();
var sut = new WorkoutService(workoutsRepoStub.Object, unitOfWorkStub.Object);
Assert.IsInstanceOf <WorkoutService>(sut);
}
public SavedController(
ExerciseService exerciseService,
WorkoutService workoutService,
UserManager <ApplicationUser> userManager)
{
_workoutService = workoutService;
_exerciseService = exerciseService;
_userManager = userManager;
}
public void GetBestTimeDaily_ShouldThrowWhenInvalidDailyIsProvided()
{
var workoutsRepoStub = new Mock <IEfRepostory <Workout> >();
var unitOfWorkStub = new Mock <IUnitOfWork>();
var sut = new WorkoutService(workoutsRepoStub.Object, unitOfWorkStub.Object);
Assert.Throws <ArgumentException>(() => sut.GetBestTimeDaily(null));
}
