public ActionResult Add(Course course)
{
if (ModelState.IsValid)
{
repository.Add(course);
return(RedirectToAction("All"));
}
else
{
return(RedirectToAction("Add"));
}
}
public void Add_WhenCalled_AddCourseToListOfCourses()
{
//Arrange
courseToAdd = new Course()
{
Name = "English club", CourseTypeId = internalCT.Id, IsDeleted = false
};
//Act
courseRepository.Add(courseToAdd);
//Assert
Assert.That(courseToAdd.Id, Is.Not.EqualTo(0));
}
public void Store(CourseDto courseDto)
{
var savedCourse = _courseRepository.GetByName(courseDto.Name);
BaseValidator.New()
.When(savedCourse != null && savedCourse.Id != courseDto.Id, Resource.CourseAlreadyExists)
.TriggersIfExceptionExists();
var publicoAlvo = _targetAudienceConverter.Converter(courseDto.TargetAudience);
var course =
new Course(courseDto.Name, courseDto.Description, courseDto.Hours, publicoAlvo, courseDto.Amount);
if (courseDto.Id > 0)
{
course = _courseRepository.GetById(courseDto.Id);
course.ChangeName(courseDto.Name);
course.ChangeAmount(courseDto.Amount);
course.ChangeHours(courseDto.Hours);
}
if (courseDto.Id == 0)
{
_courseRepository.Add(course);
}
}
public async Task <IActionResult> Post(CourseViewModelInput courseViewModelInput)
{
try
{
Course course = new Course
{
Name = courseViewModelInput.Name,
Description = courseViewModelInput.Description
};
var codigoUsuario = int.Parse(User.FindFirst(c => c.Type == ClaimTypes.NameIdentifier)?.Value);
course.CodeUser = codigoUsuario;
_courseRepository.Add(course);
_courseRepository.Commit();
var courseViewModelOutput = new CourseViewModelOutput
{
Name = course.Name,
Description = course.Description,
};
return(Created("", courseViewModelOutput));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(new StatusCodeResult(500));
}
}
public async Task <CourseViewModel> AddAsync(CourseViewModel courseViewModel)
{
var model = _mapper.Map <Course>(courseViewModel);
model.Id = 0;
model.Category = null;
var validation = new RegisterCourseValidation().Validate(model);
if (!validation.IsValid)
{
_domainNotification.AddNotifications(validation);
return(courseViewModel);
}
await ValidateBusinessRulesAsync(courseViewModel);
if (!_domainNotification.HasNotifications)
{
_courseRepository.Add(model);
_unitOfWork.Commit();
var viewModel = _mapper.Map <CourseViewModel>(model);
return(viewModel);
}
return(courseViewModel);
}
public Course DoGenerateCourse(Teacher teacher, Subject subject, StudyPlan studyPlan)
{
// Validations:
// - Schedule of Teacher
// - Valid StudyPlan
// - etc.
var studyPlanDetails = _studyPlanDetailRepository
.ObtainDetailsByStudentPlanId(studyPlan.Id)
.ToList();
if (studyPlanDetails.Count == 0)
{
throw new Exception("No details for this StudyPlan");
}
var studyPlanDetail = studyPlanDetails.FirstOrDefault(x => x.Subject.Id == subject.Id);
if (studyPlanDetail == null)
{
throw new Exception("No detail found for this StudyPlan and Subject.");
}
var course = new Course {
Id = new Guid(), HeadTeacher = teacher, Subject = subject, StudyPlanDetail = studyPlanDetail
};
var courseAdded = _courseRepository.Add(course);
return(courseAdded);
}
public void Add(CourseViewModel model)
{
var entity = mapper.Map <CourseViewModel, Course>(model);
repo.Add(entity);
repo.SaveChanges();
}
public void Save(CourseDTO courseDTO)
{
var cursoJaSalvo = _courseRepository.GetByName(courseDTO.Name);
RuleValidator.New()
.When(cursoJaSalvo != null && cursoJaSalvo.Id != courseDTO.Id, Resource.CourseNameAlreadyExists)
.When(!Enum.TryParse(courseDTO.TargetAudience, out TargetAudience targetAudience), Resource.InvalidTargetAudience)
.ThrowExceptionIfExists();
var curso = new Course(courseDTO.Name, courseDTO.Workload, targetAudience, courseDTO.CourseFee, courseDTO.Description);
if (courseDTO.Id > 0)
{
curso = _courseRepository.GetById(courseDTO.Id);
curso.UpdateName(courseDTO.Name)
.UpdateCourseFee(courseDTO.CourseFee)
.UpdateWorkload(courseDTO.Workload)
.UpdateDescription(courseDTO.Description)
.UpdateTargetAudience(targetAudience);
}
else
{
_courseRepository.Add(curso);
}
}
public async Task <CourseNotification> Handle(CourseCreateCommand request,
CancellationToken cancellationToken)
{
try
{
await _repository.Add(request.course);
var result = new CourseNotification()
{
course = request.course, message = $"Course {request.course.CourseName} was created successful."
};
await _mediator.Publish(result);
return(await Task.FromResult(result));
}
catch (Exception ex)
{
await _mediator.Publish(new ErrorNotification { ErrorDescription = ex.Message, ErrorTrace = ex.StackTrace });
var result = new CourseNotification()
{
course = request.course, message = $"Some thing is wrong cannot create the course {request.course.CourseName}."
};
return(await Task.FromResult(result));
}
}
public Course AddCourse(RegisterCourseViewModel model, int customerId)
{
Course course = new Course()
{
CustomerId = customerId,
Description = model.Description,
Name = model.Name,
TimeStamp = DateTime.Now,
};
_courseRepository.Add(course);
Scene scene = new Scene()
{
CourseId = course.Id
};
_sceneService.AddScene(scene);
VRBackground background = new VRBackground()
{
SceneId = scene.Id
};
_backgroundService.AddImage(background);
return(course);
}
public IActionResult Add(Course course)
{
if (ModelState.IsValid)
{
Course currCourse = _courseRepository.GetCourseByCurrencyName(course.CurrencyName);
if (currCourse == null)
{
_courseRepository.Add(course);
return(RedirectToAction("Index", "Course"));
}
else
{
ViewData["CourseAlrert"] = "Course already exists";
List <string> lst = new List <string>();
foreach (var item in _currencyRepository.GetAllCurrencies().ToList().OrderBy(x => x.OrderNum).ToList())
{
lst.Add(item.CurrencyCode);
}
ViewBag.UniqueCurrenciesFromCourse = new SelectList(lst);
Course newCourse = new Course();
return(View(newCourse));
}
}
return(View());
}
public CourseDto AddCourse(bool isValid, CourseDto course)
{
if (!isValid)
{
throw new ModelFormatException();
}
if (courseRepository.Get(c => c.CourseId == course.CourseId && c.Semester == course.Semester) != null)
{
throw new DuplicateException();
}
courseRepository.Add(new Course {
CourseId = course.CourseId, Semester = course.Semester, StartDate = course.StartDate, EndDate = course.EndDate, MaxStudents = course.MaxStudents
});
unitOfWork.Commit();
return(new CourseDto
{
Id = GetLatestId(),
CourseId = course.CourseId,
Semester = course.Semester,
StartDate = course.StartDate,
EndDate = course.EndDate,
MaxStudents = course.MaxStudents,
NumberOfStudents = studentService.GetAllStudentsByCourseId(GetLatestId()).Count()
});
}
// api/courses
public IHttpActionResult Post([FromBody] Course newCourse)
{
var createdCourse = _courseRepository.Add(newCourse);
var courseUrl = Url.Link("DefaultApi", new { controller = "Courses", id = createdCourse.CourseID });
return(Created(courseUrl, createdCourse));
}
public async Task <IActionResult> AddCourse([FromForm] CourseForAddDto courseForAddDto)
{
// courseCategoryForAddDto.Name = courseCategoryForAddDto.Name.ToLower();
courseForAddDto.CreatedDate = DateTime.Now;
courseForAddDto.CreatedBy = User.Identity.Name.ToString();
courseForAddDto.IdCreatedBy = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
courseForAddDto.UpdatedDate = DateTime.Now;
courseForAddDto.UpdatedBy = User.Identity.Name.ToString();
// if (await _repo.UserExists(courseCategoryForAddDto.Name))
// return BadRequest("Tài khoản đã tồn tại");
var file = courseForAddDto.File;
// _repo.Add(courseToCreate);
// await _repo.SaveAll();
var courseToCreate = _mapper.Map <Course>(courseForAddDto);
_repo.Add(courseToCreate);
await _repo.SaveAll();
int idOfCoursAdded = _repo.GetCourseMaxID();
if (file != null)
{
string newFileName = idOfCoursAdded + "_" + file.FileName;
string path = Path.Combine(_hostingEnv.ContentRootPath, "Upload", newFileName);
using (var stream = new FileStream(path, FileMode.Create))
{
file.CopyTo(stream);
courseForAddDto.Image = newFileName;
courseToCreate.Image = courseForAddDto.Image;
//_data.Entry(courseForAddDto).Property(x => x.Image).IsModified = true;
var courseFromRepo1 = await _repo.GetCourse(idOfCoursAdded);
_mapper.Map(courseToCreate, courseFromRepo1);
await _repo.SaveAll();
}
}
return(Ok(courseToCreate));
}
public async Task <Course> Add(Course course)
{
if (!Valid(course))
{
throw new InvalidUserObject("Course");
}
return(await _courseRepository.Add(course));
}
public IActionResult AddCourse([FromBody] CourseDTO dto)
{
return(this.Created(() =>
{
bool result = _CourseRepo.Add(dto).Equals((int)TransactionStatus.SUCCESS);
return result ? dto.ToJson() : new JObject();
}, _Logger));
}
public IActionResult Create(Course course)
{
if (ModelState.IsValid)
{
Course newCourse = _courserepository.Add(course);
return(RedirectToAction("Details", new { id = newCourse.Id }));
}
return(View());
}
public void AddCourse(Course course)
{
using (var transaction = new TransactionScope())
{
_courseRepository.Add(course);
_courseRepository.SaveChanges();
transaction.Complete();
}
}
public IHttpActionResult AddCourse(Course course)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
repository.Add(course);
return(CreatedAtRoute("DefaultApi", new { id = course.CourseId }, course));
}
public async Task <CQRSApp.Domain.Entites.Course> Handle(CreateCourseCommand request, CancellationToken cancellationToken)
{
CQRSApp.Domain.Entites.Course course = new CQRSApp.Domain.Entites.Course(request.DepartmentId, request.Name, request.CreditHour, request.HasPreRequest);
var newCourse = _repo.Add(course);
await _uow.Commit();
return(newCourse);
}
public JsonResult Add(Course course)
{
var result = courseRepository.Add(course);
return(Json(new {
Status = "ok",
Result = result,
}, JsonRequestBehavior.AllowGet));
}
public IActionResult Create([FromBody] CourseViewModel courseViewModel)
{
var course = Mapper.Map <CourseViewModel, Course>(courseViewModel);
CourseRepository.Add(course);
CourseRepository.SaveChanges();
return(Ok());
}
public int AddCourse(Course course)
{
using (TransactionScope tran = new TransactionScope()) {
Courses.Add(course);
// Complete();
tran.Complete();
return(course.Id);
}
}
public IActionResult Create(Course model)
{
if (ModelState.IsValid)
{
courseRepository.Add(model);
return(RedirectToAction("Index"));
}
return(View());
}
public Course Add(Course newCourse)
{
if (_courseRepository.GetByName(newCourse.Name) != null)
{
return(null);
}
var created = _courseRepository.Add(newCourse);
return(created);
}
public void Add(Course course)
{
SetCourseType(course);
ValidateCourse(course);
ValidateDuplicatedCourse(course);
course.IsDeleted = false;
_courseRepository.Add(course);
}
public ActionResult AddCourse(Course c)
{
repo.Add(c);
for (int i = 0; i < Request.Files.Count; i++)
{
HttpPostedFileBase file = Request.Files[i];
file.SaveAs(Server.MapPath(@"~\Content\themes\base\images\" + "c" + c.Id + ".jpg"));
}
return(RedirectToAction("../Admin/Courses"));
}
public IActionResult Create(CourseAddVM courseVM)
{
var course = courseVM.GetInstance();
if (ModelState.IsValid)
{
_repo.Add(course.AdviseeId, course);
return RedirectToAction("Details", "Advisee", new { id = course.AdviseeId });
}
return View(courseVM);
}
public ActionResult Create([Bind(Include = "Id,Title,Credits,DepartmentId")] Course course)
{
if (ModelState.IsValid)
{
courseRepository.Add(course);
return(RedirectToAction("Index"));
}
ListDepartments(course.DepartmentId);
return(View(course));
}
public Course CreateCourse(Course course)
{
if (!_courseRepository.Records.Any(x => x.Title == course.Title))
{
return(_courseRepository.Add(course));
}
else
{
return(null);
}
}
