public ActionResult EditCourse(int id)
{
var course = _context.Courses.SingleOrDefault(c => c.CourseId == id);
if (course == null)
{
return(HttpNotFound());
}
var specialization = _context.Specializations.ToList();
var semester = _context.Semesters.ToList();
var year = _context.Years.ToList();
if (specialization == null || semester == null || year == null)
{
return(HttpNotFound());
}
var createNewCourse = new CreateCourseViewModel
{
TeacherId = course.TeacherId.Value,
Specializations = specialization,
Semesters = semester,
Years = year,
Course = course
};
return(View("CreateOrUpdateCourse", createNewCourse));
}
public async Task CreateCourse(CreateCourseViewModel courseVM, ApplicationUser user)
{
var scheduler = new FormingScheduleService();
courseVM.Course.TeacherID = user.Id;
// courseVM.Course.Teacher = user;
courseVM.Course.TeacherInfo = new CourseTeacherInfo()
{
Skype = user.Skype, Email = user.Email, FirstName = user.FirstName, LastName = user.LastName
};
courseVM.Course.ReleaseDate = DateTime.Now;
courseVM.Course.IsActive = true;
foreach (var day in courseVM.WeekDays)
{
if (day.IsWorkDay)
{
courseVM.Course.WeekPlans.Add(day);
}
}
courseVM.Course.LessonSchedule = scheduler.FormSchedule(courseVM.Course.WeekPlans, courseVM.Course.Duration, DateTime.Now, 1);
_context.Add(courseVM.Course);
await _context.SaveChangesAsync();
}
public IActionResult Create(CreateCourseViewModel model)
{
ViewData["ReturnUrl"] = ReturnUrl;
if (ModelState.IsValid)
{
var userId = this.userManager.GetUserId(this.User);
var course = new Course
{
Name = model.Name,
Description = model.Description,
Active = 1,
Created_At = DateTime.UtcNow,
Created_By = userId,
Updated_By = null,
};
db.Course.Add(course);
db.SaveChanges();
return(RedirectToAction("List", "Course"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Create(CreateCourseViewModel model)
{
if (!ModelState.IsValid)
{
model.Trainers = await this.GetTrainersAsync();
return(View(model));
}
await this.courses.CreateAsync(
model.Name,
model.Description,
model.StartDate,
model.EndDate,
model.TrainerId
);
TempData.AddSuccessMessage($"Course {model.Name} created successfully!");
return(Redirect("/"));
// Variant 2
// redirect format: (nameof(action, controller)
// return RedirectToAction(nameof(HomeController.Index), "Home", new { area = string.Empty });
}
// GET: Courses/Edit/5
public async Task <IActionResult> Edit(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var course = await _context.Courses.FindAsync(id);
if (course == null)
{
return(NotFound());
}
CreateCourseViewModel viewModel = new CreateCourseViewModel()
{
Categories = _context.Categories.Select(x => new SelectListItem()
{
Value = x.Id.ToString(), Text = x.Name
})
};
Mapper.Map(course, viewModel);
//viewModel.Name = course.Name;
//viewModel.StartDate = course.StartDate;
//viewModel.EndDate = course.EndDate;
//viewModel.Id = course.Id;
return(View(viewModel));
}
public async Task <IActionResult> Edit(Guid id, CreateCourseViewModel viewModel)
{
//if (id != course.Id)
//{
// return NotFound();
//}
if (ModelState.IsValid)
{
try
{
var course = await _context.Courses.FindAsync(id);
Mapper.Map(viewModel, course);
_context.Update(course);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public ActionResult Create(CreateCourseViewModel courseView)
{
if (!ModelState.IsValid)
{
return(View());
}
var course = new Course(courseView)
{
MentorId = User.Identity.GetUserId(),
Mentor = _repository.UserManager.Get(u => u.Id == User.Identity.GetUserId()),
};
if (_repository.CourseManager.Contains(t => t.CompareTo(course) == 0))
{
ModelState.AddModelError("", @"Ошибка при обновлении базы данных");
}
else
{
if (_repository.CourseManager.Add(course))
{
return(RedirectToAction("Index", new { courseId = course.Id }));
}
else
{
ModelState.AddModelError("", @"Ошибка при обновлении базы данных");
}
}
return(View());
}
public ActionResult CreateCourse(CreateCourseViewModel course, int specializationId, string tutorId)
{
if (ModelState.IsValid)
{
if (CheckDates(course.StartDate, course.EndDate))
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <CreateCourseViewModel, CourseDto>();
cfg.CreateMap <SpecializationViewModel, SpecializationDto>();
});
var mapper = config.CreateMapper();
_courseService.Create(mapper.Map <CreateCourseViewModel, CourseDto>(course), specializationId, tutorId);
return(RedirectToAction("Courses", "Home"));
}
ModelState.AddModelError("", "Check dates! They are wrong");
}
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var tutorUsers = roleManager.FindByName("Tutor").Users.ToList();
List <ApplicationUser> tutors = new List <ApplicationUser>();
foreach (IdentityUserRole tutor in tutorUsers)
{
tutors.Add(UserManager.FindById(tutor.UserId));
}
ViewBag.Tutors = tutors;
var specialization = _specializationService.GetSpecializations();
ViewBag.Specializations = specialization;
ModelState.AddModelError("", "Something failed");
return(View(course));
}
public async Task <Course> AddCourse(Guid id, CreateCourseViewModel course, string userId)
{
byte[] imageData = null;
using (var binaryReader = new BinaryReader(course.Image.OpenReadStream()))
{
imageData = binaryReader.ReadBytes((int)course.Image.Length);
}
Subject subject = await _subjectService.GetSubject(id);
Course new_course = new Course()
{
Id = Guid.NewGuid(),
Modified = DateTime.Now,
Name = course.Name,
Description = course.Description,
Language = course.Language,
Image = imageData,
SubjectId = subject.Id,
AuthorId = userId,
};
await _coursesRepository.AddCourse(new_course);
return(new_course);
}
public ActionResult Save(int id, CreateCourseViewModel newCourse)
{
var course = newCourse.Course;
course.TeacherId = id;
if (course.CourseId == 0)
{
_context.Courses.Add(course);
}
else
{
var courseInDb = _context.Courses.Single(c => c.CourseId == course.CourseId);
courseInDb.CourseName = course.CourseName;
courseInDb.CourseDescription = course.CourseDescription;
courseInDb.SpecializationId = course.SpecializationId;
courseInDb.SemesterId = course.SemesterId;
courseInDb.YearId = course.YearId;
courseInDb.TeacherId = course.TeacherId;
}
_context.SaveChanges();
var teacher = _context.Teachers.SingleOrDefault(t => t.TeacherId == id);
return(RedirectToAction("CourseDetails/" + course.CourseId, "Courses"));
}
public ActionResult Create(CreateCourseViewModel model)
{
if (model.Description != null && OtherFunctions.IsHasJS(model.Description))
{
ModelState.AddModelError("", Common.FieldDescriptionDanger);
return(View(model));
}
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var teacher = this.userService.GetTeacherByAppUserId(this.User.Identity.GetUserId());
this.courseService.Add(new Course
{
Name = model.Name,
TeacherId = teacher.Id,
Descrition = model.Description,
CreationDate = DateTime.Now
});
return(Redirect("/Course/GetAllCourses"));
}
catch
{
return(View());
}
}
public IActionResult Create(CreateCourseViewModel viewModel, [FromServices] AddCourse command)
{
if (ModelState.IsValid)
{
//if course already exist return error
try
{
queryDb.Courses.Where(c => c.CourseId == viewModel.CourseId).Single();
ModelState.AddModelError(String.Empty, "A course with that Id already exists");
return(RedirectToAction("Index", "Course"));
}
catch (Exception)
{
command.CourseId = viewModel.CourseId;
command.Name = viewModel.Name;
command.InstructorId = viewModel.InstructorId;
command.Run();
if (command.status)
{
return(RedirectToAction("Index", "Course"));
}
else
{
return(RedirectToAction("Error", "Course"));
}
}
}
//Something bad happened if we got to here
return(View(viewModel));
}
public ActionResult Create(CreateCourseViewModel model)
{
try
{
if (ModelState.IsValid)
{
Course course = new Course
{
CourseID = model.CourseID,
Title = model.Title,
Credits = model.Credits,
DepartmentID = model.DepartmentID
};
db.Courses.Add(course);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (RetryLimitExceededException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.)
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
PopulateDepartmentsDropDownList(model.DepartmentID);
return(View(model));
}
public async Task <IActionResult> AddCourse([FromBody] CreateCourseViewModel courseViewModel)
{
var mentorId = Request.GetUserId();
var course = _mapper.Map <Course>(courseViewModel);
var id = await _coursesService.AddAsync(course, mentorId);
return(Ok(id));
}
public IActionResult Create()
{
var viewModel = new CreateCourseViewModel();
viewModel.Instructors = queryDb.Instructors.ToList();
//ViewBag.InstructorList = new SelectList(queryDb.Instructors.ToList(), "Id","Name");//,"Id","Instructor Name");
return(View(viewModel));
}
public ViewResult CreateCourse()
{
CreateCourseViewModel model = CreateCCVM(1);
ViewBag.search = false;
return(View("CreateCourse", model));
}
public ActionResult CreateOrUpdateCourse(int?courseId)
{
var model = new CreateCourseViewModel();
Component course;
var userId = User.Identity.GetUserId <int>();
if (!courseId.HasValue)
{
course = new Component
{
CreatorId = Convert.ToInt32(User.Identity.GetUserId()),
Created = DateTime.Now,
Type = ComponentType.Course
};
db.Components.Add(course);
var enrollment = new Enrollment
{
DateStart = DateTime.Now,
EnrolledId = userId,
EnrolledType = ComponentType.User,
EnrolleeId = course.ComponentId,
EnrolleeType = ComponentType.Course,
RoleId = (int)Role.Teacher
};
db.Enrollments.Add(enrollment);
db.SaveChanges();
model.Course = course;
model.Topics = new List <Component>();
}
else
{
course = (from a in db.Components
where a.ComponentId == courseId
select a).FirstOrDefault();
var topics = from a in db.Enrollments
where a.EnrolledId == courseId && a.EnrolleeType == ComponentType.Topic
join b in db.Components on a.EnrolleeId equals b.ComponentId
select b;
course.ImagePath = System.IO.File.Exists(Server.MapPath("/Resources/" + course.ComponentId + ".jpg")) ? ("../Resources/" + course.ComponentId + ".jpg") : "../Resources/NoImage.jpg";
foreach (var topic in topics)
{
topic.ImagePath = System.IO.File.Exists("../Resources/" + course.ComponentId + ".jpg") ? ("../Resources/" + course.ComponentId + ".jpg") : "../Resources/NoImage.jpg";
topic.EnrollmentId = course.ComponentId;
}
model.Course = course;
model.Topics = topics;
}
return(View(model));
}
public ActionResult EditCourse(CreateCourseViewModel viewObj)
{
Course courseObj = new Course();
courseObj.CourseName = viewObj.CourseName;
courseObj.ID = viewObj.ID;
_repoObj.UpdateCourse(courseObj);
return(RedirectToAction("CourseList"));
}
public void AddCourses(CreateCourseViewModel model)
{
var course = new Course();
course.Name = model.Name;
course.StartDate = model.StartDate;
_context.Courses.Add(course);
_context.SaveChanges();
}
public ActionResult AddCourse(CreateCourseViewModel viewobj)
{
Course courseObj = new Course();
courseObj.CourseName = viewobj.CourseName;
_repoObj.SaveCourse(courseObj);
RedirectToAction("CourseList");
return(RedirectToAction("CourseList"));
}
public IActionResult CreateCourse(CreateCourseViewModel model)
{
_courseService.AddNewCourse(new CourseDTO
{
Title = model.Title
});
return(RedirectToAction("Index"));
}
public ActionResult CreateCourse()
{
var model = new CreateCourseViewModel()
{
Categories = _context.Categories.ToList(),
};
return(View(model));
}
public IActionResult CreateCourse()
{
var model = new CreateCourseViewModel
{
Trainers = this.CreateTrainersSelectListItem()
};
return(View(model));
}
public IActionResult Create(CreateCourseViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_repository.AddCourses(model);
return(RedirectToAction("Index"));
}
//Add Course to db.Courses
public bool add(CreateCourseViewModel newCourse)
{
Course temp = new Course()
{
name = newCourse.name, description = newCourse.description
};
db.Courses.Add(temp);
return(Convert.ToBoolean(db.SaveChanges()));
}
public async Task <int> EditCourse(CreateCourseViewModel courseModel, int id)
{
var data = _context.Courses.Find(id);
data.Name = courseModel.Name;
data.Description = courseModel.Description;
var result = await _context.SaveChangesAsync();
return(result);
}
// GET: Course/Create
public ActionResult Create()
{
var model = new CreateCourseViewModel {
Teachers = db.Teachers.Select(t => new SelectListItem {
Text = t.Firstname + " " + t.Lastname,
Value = t.TeacherID.ToString()
}).ToList()
};
return(View(model));
}
public ActionResult EditCourse(CreateCourseViewModel model)
{
var created_course = _context.Courses.SingleOrDefault(t => t.Id == model.Id);
created_course.CourseName = model.Course.CourseName;
created_course.CourseDetail = model.Course.CourseDetail;
created_course.CategoryId = model.Course.CategoryId;
_context.SaveChanges();
return(RedirectToAction("CourseView", "Staff"));
}
public bool GetCourseEditViewModel(int id, CreateCourseViewModel course)
{
var courseToEdit = (from co in db.Courses
where co.ID == id
select co).SingleOrDefault();
courseToEdit.name = course.name;
courseToEdit.description = courseToEdit.description;
return(Convert.ToBoolean(db.SaveChanges()));
}
public ActionResult Add(CreateCourseViewModel courseVm)
{
if (this.ModelState.IsValid)
{
var newCourse = this.Mapper().Map <Course>(courseVm);
this.courses.AddCourse(newCourse);
return(this.RedirectToAction("Index", "Admin", new { area = "Admin" }));
}
return(this.View(courseVm));
}
public ActionResult CreateCourse(CreateCourseViewModel model)
{
ViewBag.AtEarliest = DateTime.Today.AddDays(1);
Menu(Home: true);
SetBreadcrumbs(
one: new MenyItem { Link = "~/Teacher/", Text = "Se alla kurser" });
if (!ModelState.IsValid)
{
return View(model);
}
model.StartDate = new DateTime(model.StartDate.Year, model.StartDate.Month, model.StartDate.Day, 0, 0, 0);
model.EndDate = new DateTime(model.EndDate.Year, model.EndDate.Month, model.EndDate.Day, 23, 59, 0);
bool hasError = false;
if (model.StartDate < DateTime.Today.AddDays(1))
{
ModelState.AddModelError("StartDate", "Startdatum kan tyvärr ej starta innan morgondagen, pga. planeringstid");
hasError = true;
}
if (model.EndDate < model.StartDate)
{
ModelState.AddModelError("EndDate", "Slutdatumet kan ej vara innan startdatumet");
hasError = true;
}
if (db.Courses.FirstOrDefault(c => c.Name == model.Name) != null)
{
ModelState.AddModelError("Name", "Namnet för denna kurs är redan upptagen");
}
if (hasError)
{
return View(model);
}
Course course = new Course { Name = model.Name, Description = (model.Description != null ? model.Description : ""), StartDate = model.StartDate, EndDate = model.EndDate };
db.Courses.Add(course);
db.SaveChanges();
return Redirect("~/Teacher/Course/"+ course.Id);
}
