public void CSI_Add_WhenAdded_CourseWillGetNewId()
{
// arrange
var courseToAdd = new Course()
{
Name = "Swimming", CourseTypeId = externalCTId, IsDeleted = false
};
// act
courseService.Add(courseToAdd);
// assert
Assert.That(courseToAdd.Id, Is.Not.EqualTo(0));
}
public ActionResult Create(CourseViewModel courseViewModel)
{
Course course = courseViewModel.Course;
IEnumerable <int> prerequisites = courseViewModel.PrerequisiteIds;
try
{
course = courseService.Add(course);
if (prerequisites != null)
{
foreach (int prerequisiteId in prerequisites)
{
Prerequisite prerequisite = new Prerequisite
{
CourseId = course.Id,
CoursePrerequisiteId = prerequisiteId
};
prerequisiteService.Add(prerequisite);
}
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View(courseViewModel));
}
}
public IHttpActionResult Post([FromBody] CourseDto form)
{
if (ModelState.IsValid)
{
try
{
var course = Mapper.Map <CourseDto, Course>(form);
_courseService.Add(course);
var courseDto = GetCourseDto(course);
return(Created(new Uri(courseDto.Url), courseDto));
}
catch (ArgumentNullException ane)
{
ModelState.AddModelError("", ane.Message);
}
catch (PreexistingEntityException pe)
{
ModelState.AddModelError("", pe.Message);
}
}
return(BadRequest(ModelState));
}
public void Add_CorrectCourse_CallsCreateAndSave()
{
_sut = new CourseService(_courseRepositoryMock.Object, _unitOfWorkMock.Object, _courseEntryRepositoryMock.Object);
_sut.Add(new Course());
_courseRepositoryMock.Verify(m => m.Create(It.IsAny <Course>()), Times.Once);
_unitOfWorkMock.Verify(m => m.SaveChanges(), Times.Once);
}
public ActionResult Add(Course course)
{
if (ModelState.IsValid)
{
_courseSrvice.Add(course);
return(View());
}
return(View(course));
}
public IActionResult Create(Course crs)
{
if (ModelState.IsValid)
{
_course.Add(crs);
return(RedirectToAction("Index"));
}
return(View(crs));
}
public IActionResult Create([FromBody] Course course)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_service.Add(course);
return(Ok(course));
}
public ActionResult Create([Bind(Include = "ID,Name")] Course Course)
{
if (ModelState.IsValid)
{
courseService.Add(Course);
return(RedirectToAction("Index"));
}
return(View(Course));
}
public IActionResult Add(Course course)
{
var result = _courseService.Add(course);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task <IActionResult> Create([Bind("Id,AuthorId,Name,PassMark,DurationInMinutes,Description,DateCreated")] CourseModel course)
{
if (ModelState.IsValid)
{
var response = await _service.Add(course);
return(RedirectToAction(nameof(Index)));
}
ViewData["AuthorId"] = new SelectList(_authorService.Get(), "Id", "Id", course.AuthorId);
return(View(course));
}
public async Task <IHttpActionResult> Add(CourseAddDto model)
{
bool result = await _courseService.Add(model);
if (!result)
{
return(BadRequest());
}
return(Ok());
}
public IHttpActionResult CreateCourse(CourseEditModel courseModel)
{
if (courseModel != null)
{
var course = _courseMapper.Map(courseModel);
List <int> wordSuitesId = courseModel.WordSuites.Select(x => x.Id).ToList();
course.Id = _courseService.Add(course, wordSuitesId);
return(Ok());
}
return(BadRequest(MessagesContainer.IncorrectData));
}
public void Create(int trainerId, string categorytitle, string title, string description, string city, string postcode, double pricePerSession, int sessionLengthMinutes, int totalSessions, DateTime availableDate, string availableTime, int maxPeople)
{
int catId = _service.GetCategoryIdFromTitle(categorytitle);
var newCourse = new Course()
{
AvailableTime = availableTime, AvailableDate = availableDate, TrainerId = trainerId, CategoryId = catId, Title = title, Description = description, City = city, PostCode = postcode, PricePerSession = pricePerSession, SessionLengthMinutes = sessionLengthMinutes, TotalSessions = totalSessions
};
_service.Add(newCourse);
_service.SaveCourseChanges();
}
public ActionResult Add(CourseViewModel course)
{
var courseToAdd = Mapper.Map <CourseViewModel, Course>(course);
var user = _userService.GetCurrent(User.Identity.Name);
courseToAdd.MasterId = user.Master.MasterId;
_courseService.Add(courseToAdd);
return(RedirectToAction("Get", "Course"));
}
public IActionResult Add(CourseViewModel model)
{
if (ModelState.IsValid)
{
courseService.Add(model);
return(RedirectToAction("Courses"));
}
else
{
return(BadRequest("Failed to add cource"));
}
}
public IActionResult Post([FromBody] CourseModel course)
{
try
{
_courseService.Add(course.ToDomainModel());
}
catch (System.Exception ex)
{
ModelState.AddModelError("AddCourse", ex.Message);
return(BadRequest(ModelState));
}
return(CreatedAtAction("Get", new { Id = course.Id }, course));
}
public ActionResult Add(Course course)
{
if (course.Id == 0) //Insert Operation
{
_courseService.Add(course);
}
else//Update Operation
{
_courseService.Update(course);
}
return(RedirectToAction("Index"));
}
public CourseViewModel Add(CourseViewModel courseViewModel)
{
var course = Mapper.Map <Course>(courseViewModel);
var courseReturn = courseService.Add(course);
if (courseReturn.ValidationResult.IsValid)
{
unitOfWork.Commit();
}
courseViewModel = Mapper.Map <CourseViewModel>(courseReturn);
return(courseViewModel);
}
public JsonResult Add(CourseViewModel model)
{
if (ModelState.IsValid)
{
var EntityMapped = Mapper.Map <Course>(model);
EntityMapped.UserId = CurrentUser.Id;
EntityMapped.CreatedDate = DateTime.Now;
_courseService.Add(EntityMapped);
return(Json(new { data = model, success = true }, JsonRequestBehavior.AllowGet));
}
var errors = ModelState.GetDistinctModelErrors();
return(Json(new { data = model, success = false, ErrorsList = errors }, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(Course course)
{
if (ModelState.IsValid)
{
_service.Add(course);
_service.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public async Task <IActionResult> Add(CourseAddDto newCourse)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var courseResult = await _courseService.Add(_mapper.Map <Course>(newCourse));
if (courseResult == null)
{
return(BadRequest());
}
return(Ok(_mapper.Map <CourseResultDto>(courseResult)));
}
public IActionResult New(CourseViewModel vm)
{
if (ModelState.IsValid)
{
var course = _mapper.Map <CourseDto>(vm);
_courseService.Add(course);
if (course.Id != default(int))
{
SetClientSideNotificationMessage(_messageProvider.SuccessMessage(OperationType.Create, "course"));
return(RedirectToAction("Edit", "Courses", new { id = course.Id }));
}
}
return(View(vm));
}
public IActionResult CourseAdd([FromBody] Course course)
{
course.ID = Guid.NewGuid();
course.CreateBy = (Guid)course.LastUpdateBy;
course.CreateTime = DateTime.Now;
course.LastUpdateTime = DateTime.Now;
course.IsDelete = false;
course.HaveStu = 0;
try
{
_course.Add(course);
}
catch (Exception e)
{
return(new JsonResult(new { code = ResultCode.错误, message = e.Message }));
}
return(new JsonResult(new { code = ResultCode.正常 }));
}
public IActionResult Add([FromBody] CourseDto Course)
{
try
{
if (courseService.Add(Course))
{
return(Ok("Successfully Added"));
}
else
{
return(BadRequest("Failed To Add"));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Create(CourseViewModel courseAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(courseAddViewModel));
}
var course = _mapping.Map <Course>(courseAddViewModel);
var operation = _courseService.Add(course);
if (operation.IsSuccessful)
{
return(this.RedirectToAction(x => x.Manage()));
}
ModelState.AddModelError(string.Empty, operation.ErrorMessage);
return(View(courseAddViewModel));
}
/// <summary>
/// Adds course in database, as well as specified categories that need to be related to added course.
/// It also relates course with specific study program and semester.
/// This method is defined in transaction scope.
/// </summary>
/// <param name="name">Name of the course to add</param>
/// <param name="categories">List of the names of the categories that needs be added</param>
/// <param name="semester">Belonging semester</param>
/// <param name="studyProgram">Belonging study program</param>
/// <returns>True if added, false if not.</returns>
public async Task <ResultMessage <bool> > SaveCourse(string name, string[] categories, Semester semester, StudyProgram studyProgram)
{
try
{
using (IDbContextTransaction transaction = await _orhedgeContext.Database.BeginTransactionAsync())
{
ResultMessage <CourseDTO> addedCourse = await _courseService.Add(new CourseDTO()
{
Name = name
});
if (!addedCourse.IsSuccess)
{
return(new ResultMessage <bool>(false, addedCourse.Status, addedCourse.Message));
}
foreach (string category in categories)
{
ResultMessage <CategoryDTO> addedCategory = await _categoryService.Add(
new CategoryDTO()
{
CourseId = addedCourse.Result.CourseId,
Name = category
});
if (!addedCategory.IsSuccess)
{
return(new ResultMessage <bool>(false, addedCategory.Status, addedCategory.Message));
}
}
ResultMessage <bool> sp = await AddInStudyProgram(addedCourse.Result.CourseId, studyProgram, semester);
if (!sp.IsSuccess)
{
return(sp);
}
transaction.Commit();
return(new ResultMessage <bool>(true, OperationStatus.Success));
}
}
catch (DbUpdateException ex)
{
return(new ResultMessage <bool>(false, _errorHandler.Handle(ex)));
}
}
public async Task <IHttpActionResult> Add([FromBody] CourseDTO course)
{
var response = new OverviewResponse <CourseOverview>();
try
{
Course newCourse = _mapper.Map <CourseDTO, Course>(course);
var result = _courseService.Add(newCourse);
if (result == null)
{
response.IsSuccess = false;
response.Errors.Add("Already exists!");
response.Overview = GetCourseOverview();
return(Ok(response));
}
var associated = _courseService.AssociateSubjects(result.Id, course.SelectedSubjects);
if (!associated)
{
response.IsSuccess = false;
response.Errors.Add("Associating course to subjects did not went well");
}
var overviews = GetCourseOverview();
response.IsSuccess = !response.Errors.Any();
response.Overview = overviews;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Errors.Add(ex.Message);
response.Errors.Add("-----------------------------------");
response.Errors.Add(ex.InnerException.Message);
var overviews = GetCourseOverview();
response.Overview = overviews;
return(Ok(response));
}
//Call overview
var hubContext = GlobalHost.ConnectionManager.GetHubContext <ClientHub>();
hubContext.Clients.All.reloadCourse(response);
return(Ok(response));
}
public IActionResult Create(Course model)
{
//check model is valid or not
if (ModelState.IsValid)
{
//check course exists or not
var course = courseService.GetByCourseCode(model.CourseCode);
if (course != null)
{
ViewBag.Error = "Course with this code already exists";
}
else
{
//save to database
courseService.Add(model);
ViewBag.Msg = "Student Created successfully";
}
}
return(View());
}
public async Task <ActionResult> Post([FromBody] CourseRequest studentRequest)
{
try
{
var response = await _courseService.Add(studentRequest);
var notifications = _courseService as Notifiable;
if (response == null && notifications.Error.Any())
{
return(BadRequest(notifications.Error));
}
return(Created(string.Empty, response));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.ToString()));
}
}
public async Task <ActionResult <CourseViewModel> > PostCourse(CourseViewModel course)
{
if (course != null)
{
try
{
await Task.Run(() =>
{
course.DateCreated = DateTime.Now;
_courseService.Add(course);
_courseService.SaveChanges();
return(Ok("thêm khóa học thành công!"));
});
}
catch
{
throw new Exception(string.Format("Lỗi khi thêm dữ liệu"));
}
}
return(CreatedAtAction("GetCourse", new { id = course.Id }, course));
}
