public async Task <IActionResult> Create(CreateExerciseViewModel model)
{
if (ModelState.IsValid)
{
_context.Add(model.Exercise);
//foreach student in the selectedStudents make a joiner table in StudentExercises
if (model.SelectedStudents != null)
{
foreach (int studentId in model.SelectedStudents)
{
StudentExercise newSS = new StudentExercise()
{
StudentId = studentId,
ExerciseId = model.Exercise.ExerciseId
};
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
// GET: Exercises/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var exercise = await _repository.GetExerciseAsync(id);
if (exercise == null)
{
return(NotFound());
}
var viewModel = new CreateExerciseViewModel
{
AllMuscles = _muscleRepository.Muscles,
Name = exercise.Name,
Description = exercise.Description,
Muscles = exercise.Muscles
};
var i = 0;
var musclesIndex = new string[viewModel.Muscles.Count];
foreach (var muscle in viewModel.Muscles)
{
musclesIndex[i] = _muscleRepository.GetIndex(muscle.Muscle).ToString();
i++;
}
ViewBag.muscles = musclesIndex;
if (exercise.ImageData != null)
{
viewModel.ImageData = exercise.ImageData.ToArray();
}
return(View(viewModel));
}
public static Response UpdateExercises(CreateExerciseViewModel model)
{
if (model.Id == Guid.Empty)
{
return(null);
}
using (var unitOfWork = RepoUnitOfWork.New())
{
var exerciseRepo = unitOfWork.TrackingRepository <ExerciseRepository>();
var exercises = exerciseRepo.Get(model.Id);
if (exercises == null)
{
return(null);
}
exercises.MuscleGroupId = model.MuscleGroupId;
exercises.PictureUrl = model.PictureUrl;
exercises.Description = model.Description;
exercises.VideoUrl = model.VideoUrl;
exercises.Name = model.Name;
var updatedExercise = exerciseRepo.Update(exercises);
if (updatedExercise == null)
{
return(null);
}
unitOfWork.CommitTransaction();
return(ResponseFactory.SuccessResponse);
}
}
public async Task <IActionResult> Create(CreateExerciseViewModel model)
{
if (ModelState.IsValid)
{
_context.Add(model.Exercise);
if (model.AssignableStudents != null)
{
foreach (int studentId in model.ExercicesToStudents)
{
StudentExercise newSE = new StudentExercise()
{
StudentId = studentId,
ExerciseId = model.Exercise.ExerciseId
};
_context.Add(newSE);
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public void AddExercise(CreateExerciseViewModel model)
{
using (var db = new GainTrackerContext(ACTIVE_CONNECTION))
{
db.Exercises.Add(Mapper.Map <Exercise>(model));
db.SaveChanges();
}
}
public ActionResult AddExercise()
{
var model = new CreateExerciseViewModel();
model.ComboTopics = adminServices.GetAllTopics();
return(View(model));
}
// GET: Exercises/Create
public IActionResult Create()
{
var viewModel = new CreateExerciseViewModel
{
AllMuscles = _muscleRepository.Muscles
};
return(View(viewModel));
}
public async Task <IActionResult> Create(CreateExerciseViewModel viewModel, string[] musclesIndex)
{
if (_repository.GetExercise(viewModel.Name) != null)
{
ModelState.AddModelError("", "Exercise with this name already exist!!!");
}
var listId = new List <int>();
foreach (var formKey in Request.Form.Keys)
{
int i;
if (int.TryParse(formKey, out i))
{
listId.Add(i);
}
}
if (listId.Count == 0)
{
ModelState.AddModelError("", "Choose at least one group of muscle");
}
try
{
if (ModelState.IsValid)
{
var saving = await _repository.SaveExerciseAsync(viewModel, 0);
if (saving != 0)
{
foreach (var i in listId)
{
var gr = await _groupOfMusclesRepository.NewGroupOfMusclesAsync(saving,
_muscleRepository.GetMuscleByIndex(i));
}
viewModel.Muscles = _groupOfMusclesRepository.GroupsOfMusclesByExercise(saving).ToList();
}
if (saving != 0)
{
return(RedirectToAction("Details", new { id = saving }));
}
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
viewModel.AllMuscles = _muscleRepository.Muscles;
return(View(viewModel));
}
public ActionResult AddExercise(CreateExerciseViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
repository.AddExercise(model);
return(RedirectToAction("Index", "Admin"));
}
public async Task <IActionResult> CreateExercise(CreateExerciseViewModel inputModel)
{
if (this.ModelState.IsValid)
{
await this.exercisesService.CreateExercise(inputModel);
return(this.Redirect("/Exercises/AllExercises"));
}
return(this.View(inputModel));
}
public ActionResult Create()
{
var model = new CreateExerciseViewModel()
{
Section = context.Sections.ToList(),
SchoolList = context.SchoolList.ToList(),
SchoolClassList = context.SchoolClassList.ToList()
};
return(View("Create", model));
}
public Response Update(CreateExerciseViewModel model)
{
var savedResponse = ExerciseCore.UpdateExercises(model);
if (savedResponse == null)
{
return(ResponseFactory.ErrorReponse);
}
return(ResponseFactory.SuccessResponse);
}
public async Task CreateExercise(CreateExerciseViewModel inputModel)
{
var exercise = new Exercise
{
Name = inputModel.Name,
Description = inputModel.Description,
};
await this.db.Exercises.AddAsync(exercise);
await this.db.SaveChangesAsync();
}
public ActionResult CreateExercise(CreateExerciseViewModel exercise)
{
if (this.ModelState.IsValid)
{
var exerciseDataModel = this.mapper.Map <Exercise>(exercise);
this.exerciseService.AddExercise(exerciseDataModel);
return(this.RedirectToAction("Index"));
}
return(this.View());
}
public JsonResult Save(CreateExerciseViewModel model)
{
var response = ResponseFactory.ErrorReponse;
if (model.Id == Guid.Empty)
{
response = Create(model);
}
else
{
response = Update(model);
}
return(Json(response, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Edit(int id, CreateExerciseViewModel viewModel, string[] musclesIndex)
{
if (id == 0)
{
return(NotFound());
}
var listId = new List <int>();
foreach (var s in musclesIndex)
{
listId.Add(int.Parse(s));
}
if (listId.Count == 0)
{
ModelState.AddModelError("", "Choose at least one group of muscle");
}
try
{
if (ModelState.IsValid)
{
_groupOfMusclesRepository.DeleteGroupOfMuscle(
_groupOfMusclesRepository.GroupsOfMusclesByExercise(id).ToList());
foreach (var i in listId)
{
var gr = await _groupOfMusclesRepository.NewGroupOfMusclesAsync(id,
_muscleRepository.GetMuscleByIndex(i));
}
viewModel.Muscles = _groupOfMusclesRepository.GroupsOfMusclesByExercise(id).ToList();
}
var saving1 = await _repository.SaveExerciseAsync(viewModel, id);
if (saving1 != 0)
{
return(RedirectToAction("Details", new { id }));
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
viewModel.AllMuscles = _muscleRepository.Muscles;
return(View(viewModel));
}
public Response Create(CreateExerciseViewModel model)
{
var file = Request.Files["PictureUrl"];
var url = AzureHelper.Upload(file, "PictureUrl", Guid.NewGuid());
model.PictureUrl = url;
var creationResponse = ExerciseCore.CreateExercises(model);
if (creationResponse == null)
{
return(ResponseFactory.ErrorReponse);
}
return(ResponseFactory.SuccessResponse);
}
public async Task <int> SaveExerciseAsync(CreateExerciseViewModel viewModel, int id = 0)
{
var exercise = new Exercise();
if (id != 0)
{
exercise = await GetExerciseAsync(id);
if (exercise == null)
{
return(0);
}
if (viewModel.Muscles != null)
{
exercise.Muscles = viewModel.Muscles;
}
}
exercise.Name = viewModel.Name;
exercise.Description = viewModel.Description;
if (viewModel.image != null)
{
using (var memoryStream = new MemoryStream())
{
await viewModel.image.CopyToAsync(memoryStream);
exercise.ImageData = memoryStream.ToArray();
exercise.ImageMimeType = viewModel.image.ContentType;
}
}
if (id == 0)
{
context.Exercise.Add(exercise);
context.SaveChanges();
return(GetExercise(exercise.Name).ExerciseID);
}
context.Update(exercise);
context.SaveChanges();
return(id);
}
public ActionResult AddExercise(CreateExerciseViewModel model)
{
try
{
if (ModelState.IsValid)
{
var result = adminServices.CreateNewExercise(model, User.Identity.GetUserId());
return(PartialView("_CreateExerciseResult", result));
}
throw new Exception();
}
catch
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
}
public ActionResult Create(CreateExerciseViewModel exercise)
{
if (!ModelState.IsValid)
{
var model = new CreateExerciseViewModel()
{
Section = context.Sections.ToList(),
SchoolList = context.SchoolList.ToList(),
SchoolClassList = context.SchoolClassList.ToList()
};
return(View("Create", model));
}
if (Request.Files.Count > 0)
{
HttpPostedFileBase Foto = Request.Files[0];
if (Foto != null && Foto.ContentLength > 0)
{
var fileName = Path.GetFileNameWithoutExtension(Foto.FileName);
var fileExtension = Path.GetExtension(Foto.FileName);
fileName = fileName + DateTime.Now.ToString("fff-dd-MM-yyyy") + fileExtension;
exercise.FotoPath = "~/HomeworkFotos/" + fileName;
fileName = Path.Combine(Server.MapPath("~/HomeworkFotos/"), fileName);
Foto.SaveAs(fileName);
}
}
var newExercise = new Exercises()
{
SectionId = exercise.SectionId,
SchoolListId = exercise.SchoolListId,
SchoolClassListId = exercise.SchoolClassListId,
Topic = exercise.Topic,
Content = exercise.Content,
FotoPath = exercise.FotoPath
};
context.Excercises.Add(newExercise);
context.SaveChanges();
return(RedirectToAction("Index", "Exercise"));
}
public static CreateExerciseViewModel GetExerciseDetails(Guid exerciseId)
{
var exercise = Get(exerciseId, new[] { nameof(Exercise.MuscleGroup) });
if (exercise == null)
{
return(null);
}
var returnedModel = new CreateExerciseViewModel()
{
Id = exercise.Id,
Description = exercise.Description,
MuscleGroupId = exercise.MuscleGroupId,
PictureUrl = exercise.PictureUrl,
SectionId = exercise.MuscleGroup.MuscleSectionStatus
};
return(returnedModel);
}
public ActionResult Edit(int id)
{
var model = new CreateExerciseViewModel()
{
Id = id,
SchoolListId = context.Excercises.SingleOrDefault(e => e.Id == id).SchoolListId,
SchoolClassListId = context.Excercises.SingleOrDefault(e => e.Id == id).SchoolClassListId,
SectionId = context.Excercises.SingleOrDefault(e => e.Id == id).SectionId,
Topic = context.Excercises.SingleOrDefault(e => e.Id == id).Topic,
Content = context.Excercises.SingleOrDefault(e => e.Id == id).Content,
FotoPath = context.Excercises.SingleOrDefault(e => e.Id == id).FotoPath,
Section = context.Sections.ToList(),
SchoolList = context.SchoolList.ToList(),
SchoolClassList = context.SchoolClassList.ToList()
};
return(View("Create", model));
}
public async Task <IActionResult> Create(CreateExerciseViewModel model)
{
if (ModelState.IsValid)
{
_context.Add(model.Exercise);
foreach (int StudentId in model.SelectedStudents)
{
StudentExercise newSE = new StudentExercise()
{
ExerciseId = model.Exercise.ExerciseId,
StudentId = StudentId
};
_context.Add(newSE);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public static Response CreateExercises(CreateExerciseViewModel model)
{
var tobeCreatedExercise = new Exercise
{
Id = Guid.NewGuid(),
PictureUrl = model.PictureUrl,
Description = model.Description,
VideoUrl = model.VideoUrl,
MuscleGroupId = model.MuscleGroupId,
Name = model.Name,
Status = (int)EntityStatus.ACTIVE,
};
var createdExecise = Create(tobeCreatedExercise);
if (createdExecise == null)
{
return(null);
}
return(ResponseFactory.SuccessResponse);
}
public void CreateExercisePost_ShouldRedirectToIndexActionWhenModelIsValid()
{
var mapperStub = new Mock <IMapper>();
var exerciseServiceStub = new Mock <IExerciseService>();
var workoutInformationServiceStub = new Mock <IWorkoutInformationService>();
var weekScheduleServiceStub = new Mock <IWeekScheduleService>();
var modelViewFactoryStub = new Mock <IModelViewFactory>();
var sut = new ManagerController(mapperStub.Object, exerciseServiceStub.Object, workoutInformationServiceStub.Object, weekScheduleServiceStub.Object, modelViewFactoryStub.Object);
var exerciseViewModel = new CreateExerciseViewModel();
var exerciseDataModel = new Exercise();
mapperStub.Setup(x => x.Map <Exercise>(It.IsAny <CreateExerciseViewModel>())).Returns(exerciseDataModel);
exerciseServiceStub.Setup(x => x.AddExercise(It.IsAny <Exercise>()));
sut
.WithCallTo(x => x.CreateExercise(exerciseViewModel))
.ShouldRedirectTo(c => c.Index());
}
public Boolean?CreateNewExercise(CreateExerciseViewModel model, string userId)
{
try
{
Exercise exercise = new Exercise();
exercise.ExerciseId = context.Exercises.Count() + 1;
exercise.Problem = model.Exercise.Problem;
exercise.Development = model.Exercise.Development;
exercise.Solution = model.Exercise.Solution;
exercise.Description = model.Exercise.Description;
exercise.Topic = context.Topics.FirstOrDefault(t => t.TopicId == model.Topic.TopicId);
exercise.User = context.Users.FirstOrDefault(u => u.Id == userId);
context.Exercises.Add(exercise);
context.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public void CreateExercisePost_ShouldCallExerciseServiceCreateExerciseWithMappedModel()
{
var mapperStub = new Mock <IMapper>();
var exerciseServiceStub = new Mock <IExerciseService>();
var workoutInformationServiceStub = new Mock <IWorkoutInformationService>();
var weekScheduleServiceStub = new Mock <IWeekScheduleService>();
var modelViewFactoryStub = new Mock <IModelViewFactory>();
var sut = new ManagerController(mapperStub.Object, exerciseServiceStub.Object, workoutInformationServiceStub.Object, weekScheduleServiceStub.Object, modelViewFactoryStub.Object);
var exerciseViewModel = new CreateExerciseViewModel();
var exerciseDataModel = new Exercise();
mapperStub.Setup(x => x.Map <Exercise>(It.IsAny <CreateExerciseViewModel>())).Returns(exerciseDataModel);
exerciseServiceStub.Setup(x => x.AddExercise(It.IsAny <Exercise>()));
sut
.WithCallTo(x => x.CreateExercise(exerciseViewModel));
exerciseServiceStub.Verify(x => x.AddExercise(exerciseDataModel), Times.Once);
}
public async Task <IActionResult> Create(CreateExerciseViewModel viewmodel)
{
if (ModelState.IsValid)
{
_context.Add(viewmodel.Exercise);
if (viewmodel.SelectedStudents != null)
{
foreach (int assignedStudentId in viewmodel.SelectedStudents)
{
StudentExercise newSE = new StudentExercise()
{
StudentId = assignedStudentId,
ExerciseId = viewmodel.Exercise.ExerciseId
};
_context.Add(newSE);
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewmodel));
}
public async Task <IActionResult> Create(CreateExerciseViewModel model)
{
if (ModelState.IsValid)
{
_context.Add(model.Exercise);
foreach (int studentId in model.SelectedStudents)
{
// create a new instance of StudentExercise for each selected student
StudentExercise newSE = new StudentExercise()
{
ExerciseId = model.Exercise.ExerciseId,
StudentId = studentId
};
// insert each selected exercise to the StudentExercise join table in db
_context.Add(newSE);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public IActionResult Create(CreateExerciseViewModel model)
{
var user = userManager.GetUserAsync(HttpContext.User).Result;
if (ModelState.IsValid)
{
var course = courseManager.GetById(model.CourseId);
ExerciseDTO task = new ExerciseDTO
{
CourseId = model.CourseId,
Course = course.Name,
TaskName = model.TaskName,
TaskTextField = model.TaskTextField,
TaskBaseCodeField = model.TaskBaseCodeField,
TestCasesCode = model.TestCases,
TeacherId = user.Id,
Rating = 0,
CreateDateTime = DateTime.Now,
UpdateDateTime = DateTime.Now
};
exerciseManager.Insert(task);
}
return(RedirectToAction("Index", "ExerciseManagement"));
}
