public async Task <ActionResult <CourseDto> > CreateCourse(
Guid classId,
Guid studentId,
[FromBody] CourseAddDto course
)
{
if (!await _studentRepository.StudentExitAsync(studentId))
{
return(NotFound());
}
var entity = _mapper.Map <Course>(course);
entity.CourseId = Guid.NewGuid();
entity.StudentId = studentId;
_courseRepository.AddCourse(studentId, entity);
await _courseRepository.SaveAsync();
var dtoToReturn = _mapper.Map <CourseDto>(entity);
return(CreatedAtRoute(
nameof(GetCourse),
new{
classId = classId,
studentId = studentId,
courseId = dtoToReturn.CourseId
}, dtoToReturn
));
}
public async Task <ActionResult <CourseDto> > CreateCourse([FromBody] CourseAddDto courseAddDto)
{
//ApiController在遇到courseAddDto为空时可以自动返回400错误
var course = _mapper.Map <Course>(courseAddDto);
_courseRepository.AddCourse(course);//只是被添加到DbContext里
await _courseRepository.SaveAsync();
var courseDto = _mapper.Map <CourseDto>(course);
return(CreatedAtRoute(nameof(GetCourse), new { courseId = course.CourseId }, courseDto));
}
public async Task <IActionResult> AddCourse([FromBody] Courses courses)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await _courseRepository.CourseNameExists(courses.Name))
{
ModelState.AddModelError("Title", "Course with that name already exists.");
}
var newCourse = Mapper.Map <Courses>(courses);
_courseRepository.AddCourse(newCourse);
var saved = await _courseRepository.Save();
if (!saved)
{
return(StatusCode(500, "Error when adding course. Please try again."));
}
var returnCourse = Mapper.Map <CourseDto>(newCourse);
return(CreatedAtAction("GetCourse", new { id = returnCourse.Id }, returnCourse));
}
public PartialViewResult Createcourse(CourseTestViewModel model)
{
if (ModelState.IsValid)
{
var course = new Course
{
};
//save
_courseRepository.AddCourse(model.Course);
_courseRepository.Save();
}
else
{
//error
}
var courses = _courseRepository.GetAllCourses();
var CoursesModel = new List <Course>();
foreach (var c in courses)
{
CoursesModel.Add(new Course
{
CourseId = c.CourseId,
CourseName = c.CourseName,
Instructor = c.Instructor
});
}
var viewModel = new CourseTestViewModel()
{
Courses = CoursesModel
};
return(PartialView("_CourseTable", viewModel));
}
public IActionResult AddCourse([FromBody] AddCourseViewModel vm)
{
try
{
if (ModelState.IsValid)
{
Instructor instructor = new Instructor
{
FullName = vm.InstructorName
};
Course course = new Course
{
Instructor = instructor,
CourseName = vm.CourseName,
};
_courseRepository.AddCourse(course);
_courseRepository.Save();
}
else
{
return(Ok(new { status = "error" }));
}
}
catch (Exception ex)
{
Console.WriteLine("There was an error: {0}", ex.Message);
return(Ok(new { status = "error" }));
}
return(Ok(new { status = "success" }));
}
public IActionResult PostCourse([FromBody] CourseChangeViewModel course)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(repo.AddCourse(course)));
}
public IActionResult Index(Models.Course model)
{
if (ModelState.IsValid)
{
courseRepository.AddCourse(model);
return(RedirectToAction("index"));
}
return(View());
}
public void AddCourse(Course course)
{
_courseRepository.AddCourse(course);
if (!_courseRepository.Save())
{
throw new Exception("Could not save Course to the database");
}
}
public async Task <ActionResult <Course> > PostCourse(CourseAtCreation courseToInsert)
{
var courseEntity = _mapper.Map <Course>(courseToInsert);
_repo.AddCourse(courseEntity);
await _repo.SaveChangesAsync();
return(CreatedAtAction("GetCourse", new { id = courseEntity.Id }, courseEntity));
}
/// <summary>
/// Methods adds a new course
/// </summary>
/// <param name="course">Course needed to add</param>
/// <returns>Course that was created</returns>
public Course AddCourse(Course course)
{
if (GetCourseByName(course.Name) != null)
{
return(null);
}
else
{
return(_courseRepository.AddCourse(course));
}
}
public ActionResult Create([Bind(Include = "CourseID,Title,Credits,DepartmentID")] Course course)
{
if (ModelState.IsValid)
{
courseRepository.AddCourse(course);
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = courseRepository.GetDepartments(course);
return(View(course));
}
public IActionResult PostCourse(Course course)
{
Guid newId = new Guid();
course.Id = newId;
_courseRepository.AddCourse(course);
_courseRepository.SaveChanges();
_logger.LogInformation($"Course with id: {course.Id} has been added.");
return(CreatedAtAction(nameof(Get), new { id = course.Id }, course));
}
public IActionResult AddCourse(CourseViewModel model)
{
if (ModelState.IsValid)
{
Course newModel = new Course
{
Title = model.Title
};
courseRepository.AddCourse(newModel);
return(RedirectToAction("AddCourse"));
}
return(View(model));
}
public IActionResult AddCourse(int courseId)
{
var accountId = Request.Cookies["id"];
_courseRepository.AddCourse(courseId, Int32.Parse(accountId));
HttpContext.Session.SetString("success", "Đăng ký khóa học thành công");
List <Course> courses = _courseRepository.GetMyCourse(Int32.Parse(accountId));
MyCourseViewModel myCourseViewModel = new MyCourseViewModel
{
courses = courses,
success = HttpContext.Session.GetString("success")
};
return(View("MyCourse", myCourseViewModel));
}
public IActionResult Create(Course newCourse)
{
if (ModelState.IsValid)
{
newCourse.UserEmail = User.Identity.Name;
_courseRepo.AddCourse(newCourse);
TempData["Success"] = "Course Successfully Created!";
return(RedirectToRoute(new
{
controller = "Profile",
action = "Index"
}));
}
return(View(newCourse));
}
public void Store(CourseDto course)
{
var savadCourse = _courseRepository.AddCourseByName(course.Name);
if (savadCourse != null)
{
throw new ArgumentException("Course name unavailable");
}
if (!Enum.TryParse <TargetAudience>(course.TargetAudience, out var targetAudience))
{
throw new ArgumentException("Target Audience invalid");
}
var courseToStorage = new Course(course.Name, course.Description, course.WorkLoad, (TargetAudience)targetAudience, course.Price);
_courseRepository.AddCourse(courseToStorage);
}
public HttpResponseMessage AddCourse(CourseModel courseModel)
{
try
{
HttpResponseMessage hrm = new HttpResponseMessage(HttpStatusCode.Created)
{
Content = new StringContent(JsonConvert.SerializeObject(courseRepository.AddCourse(courseModel)))
};
return(hrm);
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
HttpResponseMessage hr = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(errors.ToString())
};
return(hr);
}
}
public IActionResult AddCourse(CourseModel courseModel)
{
try
{
if (courseModel == null)
{
return(BadRequest("Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(BadRequest(errors));
}
CourseModel addedCourse = courseRepository.AddCourse(courseModel);
return(StatusCode(StatusCodes.Status201Created, addedCourse));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(StatusCode(StatusCodes.Status500InternalServerError, errors));
}
}
public HttpResponseMessage AddCourse(CourseModel courseModel)
{
try
{
if (courseModel == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
CourseModel addedCourse = courseRepository.AddCourse(courseModel);
return(Request.CreateResponse(HttpStatusCode.Created, addedCourse));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, errors));
}
}
public async Task <IActionResult> AddCourse(CourseEntity model)
{
if (ModelState.IsValid)
{
try
{
var CourseId = _courseService.AddCourse(model);
if (CourseId > 0)
{
return(Ok(CourseId));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <IActionResult> AddNewCourse([FromBody] CourseModel model)
{
var newCourse = await _courseRepository.AddCourse(model);
return(Ok(newCourse.ToResponse("Successful")));
}
public void Post([FromBody] Course course)
{
_courseRepository.AddCourse(course);
}
public IActionResult AddCourse(Course course)
{
_CourseRepository.AddCourse(course);
return(RedirectToAction("Course", "Home"));
}
private IEntityDTO AddCourse(string teacherName, int disciplineID) => _courseRep.AddCourse(teacherName, disciplineID);
public async Task <ActionResult> PostCourse(CourseInsertDTO course)
{
var courseId = await _courseRepository.AddCourse(course.ToEntity());
return(Ok());
}
public IActionResult AddNewCourse([FromBody] Course body)
{
var response = _repo.AddCourse(body);
return(Ok(response.Result.ToString()));
}
public ActionResult <Course> Post([FromBody] Course course)
{
return(_contex.AddCourse(course));
}
public IActionResult AddCourse(Course Course)
{
var MyCourse = _IcourseRepository.AddCourse(Course);
return(Created(HttpContext.Request.Scheme + "://" + HttpContext.Request.Host + HttpContext.Request.Path + "/" + Course.CourseCode, MyCourse));
}
