public StudentEditViewModel(string connectionString)
{
_connectionString = connectionString;
//student = StudentRepository.GetOneStudent(studentId);
// Get the exercises that are currently assigned to this student
// The student model already has a list for this!
Student.StudentExs = GetAssignedExercisesByStudent(studentId);
allExercises = ExerciseRepository.GetAllExercises()
.Select(singleExercise => new SelectListItem()
{
Text = singleExercise.Name,
Value = singleExercise.id.ToString(),
Selected = Student.StudentExs.Find(assignedExercise => assignedExercise.id == singleExercise.id) != null
})
.ToList();
//Query the database to get all cohorts
Cohorts = GetAllCohorts()
.Select(cohort => new SelectListItem()
{
Text = cohort.CohortName,
Value = cohort.CohortId.ToString()
})
.ToList();
// Add an option with instructions for how to use the dropdown
Cohorts.Insert(0, new SelectListItem
{
Text = "Choose a cohort",
Value = "0"
});
}
public App()
{
InitializeComponent();
ORMRepo = new OneRepMaxRepository(dbPath);
ExerciseRepo = new ExerciseRepository(dbPath);
MainPage = new NavigationPage(new MainPage());
}
public HomeController()
{
context = new ApplicationDbContext();
patientRepository = new PatientRepository(context);
exerciseRepository = new ExerciseRepository(context);
graphRepository = new GraphRepository(context);
}
public async Task ReturnCorrectlyQueriedCollection()
{
var(connection, options) = await CreateUniqueMockDbConnectionForThisTest();
try
{
using (var context = new FittifyContext(options))
{
var exercisesFromContext = await context
.Exercises
.Where(w => w.OwnerGuid == _ownerGuid || w.OwnerGuid == null)
.Where(w => w.Name.ToLower().Contains("thexercise"))
.ToListAsync();
var serializedExercisesFromContext = JsonConvert.SerializeObject(exercisesFromContext);
var resourceParameters = new ExerciseResourceParameters()
{
OwnerGuid = _ownerGuid, SearchQuery = "thexercise"
};
var exerciseRepository = new ExerciseRepository(context);
var exerciseCollection = await exerciseRepository.GetPagedCollection(resourceParameters);
var serializedCategoriesFromRepo = JsonConvert.SerializeObject(exerciseCollection);
Assert.AreEqual(serializedExercisesFromContext, serializedCategoriesFromRepo);
}
}
finally
{
connection.Close();
}
}
public UsersController(UserRepository userRepository, ExerciseRepository exerciseRepository, WorkoutInvitationRepository workoutInvitationRepository, IMapper mapper)
{
this.userRepository = userRepository;
this.exerciseRepository = exerciseRepository;
this.workoutInvitationRepository = workoutInvitationRepository;
this.mapper = mapper;
}
static void Main(string[] args)
{
ExerciseRepository ERepo = new ExerciseRepository();
var EList = ERepo.GetAllExercises();
foreach (var item in EList)
{
Console.WriteLine($"{item.Name}, written in {item.Language}");
}
Exercise newExercise = new Exercise()
{
Name = "Food",
Language = "JS"
};
ERepo.AddExercise(newExercise);
var EJSList = ERepo.GetAllJSExercises();
foreach (var item in EJSList)
{
Console.WriteLine($"{item.Name}, written in {item.Language}");
}
}
public ActionResult Edit(int id, StudentEditViewModel model)
{
try
{
// Update the student record in the database
model.Student.Id = id;
StudentRepository.UpdateStudent(model.Student);
// Clear out all assigned exercises
ExerciseRepository.ClearAssignedExercises(model.Student.Id);
// Assign exercises selected in the form
if (model.SelectedExercises.Count > 0)
{
model.SelectedExercises.ForEach(i =>
ExerciseRepository.AssignToStudent(i, model.Student.Id));
}
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(View(model));
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
// I still don't understand what this does
StudentRepository.SetConfig(Configuration);
CohortRepository.SetConfig(Configuration);
ExerciseRepository.SetConfig(Configuration);
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
private async Task AddWorkout()
{
if (_workout.Workout_Name is null)
{
await Application.Current.MainPage.DisplayAlert("Error", "Please Enter the Workout Name", "OK");
return;
}
else
{
_workoutRepository = new WorkoutRepository();
_workoutDaysRepository = new WorkoutDaysRepository();
_exerciseRepository = new ExerciseRepository();
_workoutWeeksrepository = new WorkoutWeeksRepository();
Workouts oLastWorkout = await _workoutRepository.AddWorkout(_workout);
foreach (var item in _weeksList)
{
var weekId = await _workoutWeeksrepository.AddWorkoutWeek(new WorkoutWeeks { Week = item.Week, Workout_Id = oLastWorkout.Workout_id });
foreach (var item2 in item.Days)
{
var dayId = await _workoutDaysRepository.AddWorkoutDay(new WorkoutDays { Day = item2.Day.ToString(), Workout_Week_Id = weekId.Id, Workout_Id = oLastWorkout.Workout_id });
foreach (var item3 in item2.exercisesOnDays)
{
await _exerciseRepository.AddExercise(new Exercises { Day_Id = dayId.Id, Exercise_Name = item3.ExerciseId, Sets = item3.Reps, Reps = item3.Reps, Workout_Id = oLastWorkout.Workout_id });
}
}
}
await _navigation.PopAsync();
}
}
public void CadAddNull_ShouldThrowArgumentNullException()
{
using var context = new DataContext(ContextOptions);
var exerciseRepo = new ExerciseRepository(context);
Assert.Throws <ArgumentNullException>(() => exerciseRepo.Add(null));
}
public UnitOfWork(FitTrackerContext context)
{
_context = context;
ActivityRepository = new ActivityRepository(_context);
ExerciseRepository = new ExerciseRepository(_context);
WorkoutRepository = new WorkoutRepository(_context);
}
public ExerciseInstancesController(ExerciseContext db, ExerciseRepository repository,
UserManager <User> userManager)
{
_db = db;
_repository = repository;
_userManager = userManager;
}
private async Task AddExercise(DataContext context)
{
var repo = new ExerciseRepository(context);
var exercise = Exercise.Create("Exercise 1", await GetUser(context));
repo.Add(exercise);
await repo.SaveAll();
}
public ActionResult ViewCompleteCountForExercises()
{
List <CompletedCountForExerciseModel> completeCountForExercises = ExerciseRepository.GetCompletedCountPerExercise();
return(View(completeCountForExercises));
//need view for this. view will be the viewcoplete thing. pass the completedcountforexercise model
}
public ExerciseRepositoryTests()
{
System.Reflection.FieldInfo fi = typeof(ExerciseRepository).GetField("_instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
Assert.NotNull(fi);
fi.SetValue(null, null);
_exerciseRepository = ExerciseRepository.getInstance();
PrepareData();
}
public void Add(Exercise exercise)
{
var userId = new Guid(User.Identity.GetUserId());
exercise.UserId = userId;
ExerciseRepository.Add(exercise);
}
public WorkoutTableEventHandler(
WorkoutTableHandler workoutTableHandler,
ActivityTableHandler activityTableHandler,
ExerciseRepository exerciseRepository)
{
_workoutTableHandler = workoutTableHandler;
_activityTableHandler = activityTableHandler;
_exerciseRepository = exerciseRepository;
}
public ActivitiesCopiedFromWorkoutHandler(
PendingActivityTableStorageHandler activitiesCopiedFromWorkoutTableStorageHandler,
WorkoutTableHandler workoutTableHandler,
ExerciseRepository exerciseRepository)
{
this._activitiesCopiedFromWorkoutTableStorageHandler = activitiesCopiedFromWorkoutTableStorageHandler;
this.workoutTableHandler = workoutTableHandler;
_exerciseRepository = exerciseRepository;
}
static void Main()
{
WindowFormsFactory _formsFactory = new WindowFormsFactory();
MainController mainController = new MainController(_formsFactory, ExerciseRepository.getInstance(), WorkoutRepository.getInstance(), WeightMeasureRepository.getInstance());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmMain(mainController));
}
public UnitOfWork(RoutineMsDbContext dbContext)
{
_dbContext = dbContext;
Routines = new RoutineRepository(_dbContext);
Exercises = new ExerciseRepository(_dbContext);
SetsDetails = new SetDetailRepository(_dbContext);
Days = new DayRepository(_dbContext);
}
public ExercisesController(ExerciseRepository exerciseRepository, MuscleRepository muscleRepository,
EquipmentRepository equipmentRepository, ExerciseCategoryRepository exerciseCategoryRepository, IMapper mapper)
{
this.exerciseRepository = exerciseRepository;
this.muscleRepository = muscleRepository;
this.equipmentRepository = equipmentRepository;
this.exerciseCategoryRepository = exerciseCategoryRepository;
this.mapper = mapper;
}
public ApplicationRepository()
{
_ctx = new ApplicationDbContext();
_userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(_ctx));
RefreshTokens = new RefreshTokenRepository(_ctx);
Clients = new ClientRepository(_ctx);
Exercise = new ExerciseRepository(_ctx);
Schedules = new ScheduleRepository(_ctx);
Practices = new PracticeRepository(_ctx);
}
public UnitOfWork(AppDbContext context)
{
_context = context;
ExerciseRepository = new ExerciseRepository(context);
_disposableObjects = new List <IDisposable> {
context, ExerciseRepository
};
}
async void OnSaveButtonClicked(object sender, EventArgs e)
{
var exercise = (Exercise)BindingContext;
var ExerciseTypes = getExerciseTypes();
exercise.Name = ExerciseName.Text.ToString();
exercise.BodyPart = BodyPartPicker.SelectedItem.ToString();
exercise.EquipNeeded = ExerciseTypes;
ExerciseRepository.add(exercise);
await Navigation.PopAsync();
}
private void ExerciseSelectFactory()
{
//var exercises = ExerciseRepository.GetExercises();
Exercises = ExerciseRepository.GetExercises()
.Select(e => new SelectListItem
{
Text = e.Title,
Value = e.Id.ToString(),
Selected = student.AssignedExercises.Find(ex => ex.Id == e.Id) != null
}).ToList();
}
private void BuildExerciseOptions()
{
//var exercises = ExerciseRepository.GetExercises();
Exercises = ExerciseRepository.GetExercises()
.Select(e => new SelectListItem
{
Text = e.Name,
Value = e.Id.ToString(),
Selected = Student.AssignedExercises.Find(ex => ex.Id == e.Id) != null
}).ToList();
}
public HomeworksController(IHomeworkLogic homeworks = null) : base()
{
if (homeworks == null)
{
var context = ContextFactory.GetNewContext();
var homeworkRepo = new HomeworkRepository(context);
var exerciseRepo = new ExerciseRepository(context);
homeworks = new HomeworkLogic(homeworkRepo, exerciseRepo);
}
this.homeworks = homeworks;
}
public ActionResult Delete(int id, IFormCollection collection)
{
if (ExerciseRepository.DeleteExercise(id))
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(RedirectToAction(nameof(Details), new { id = id }));
}
}
public UnitOfWork(StudentHelperContext context)
{
_StudentHelperContext = context;
Assignments = new AssignmentRepository(_StudentHelperContext);
Courses = new CourseRepository(_StudentHelperContext);
Exercises = new ExerciseRepository(_StudentHelperContext);
Students = new StudentRepository(_StudentHelperContext);
Teachers = new TeacherRepository(_StudentHelperContext);
HelpRequests = new HelpRequestRepository(_StudentHelperContext);
StudentExercises = new StudentExerciseRepository(_StudentHelperContext);
StudentAssignments = new StudentAssignmentRepository(_StudentHelperContext);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Workouts = new WorkoutRepository(context);
Exercises = new ExerciseRepository(context);
Cardios = new CardioRepository(context);
Achievements = new AchievementsRepository(context);
Users = new ApplicationUserRepository(context);
DailyMenus = new DailyMenuRepository(context);
Foods = new FoodsRepository(context);
Measurements = new MeasurementsRepository(context);
}
public ExerciseLibraryService(ExerciseRepository repo)
{
_repo = repo;
}
